Video: The Governance Blueprint CoEs Use to Scale Self-Service and AI Agents | Duration: 2608s | Summary: The Governance Blueprint CoEs Use to Scale Self-Service and AI Agents | Chapters: Welcome and Introduction (0s), Balancing Governance and Self-Service (56.66356878919079s), AI Governance Implementation (854.3835687891908s), AI Governance Foundations (917.3485687891908s), Governance Framework Implementation (1493.803468789191s), Q&A Session Transition (1931.8035687891909s), Governance and Automation (1973.358568789191s), Closing Thoughts (2496.5735687891906s)
Transcript for "The Governance Blueprint CoEs Use to Scale Self-Service and AI Agents":
let's talk about why we're here. Governance shouldn't be a blocker and self serve service shouldn't be a risk. But without alignment, they often pull in opposite directions. So today's session is all about how to change that that, and we'll take a look at how CoEs are implementing architectural governance with Dataiku to make sure the safest path is also the easiest one. So today, you'll see how organizations are streamlining compliance with tools like the Dataiku project assessment tool and Dataiku govern. And, also, how they're building COEs that balance trust, autonomy, and accountability by design. Last but not least, we are thrilled to be joined by our two in house experts, John Tudor, director of business architecture here at Dataiku, and also Jacob Beswick, director of AI governance solutions at Dataiku. Now I'll hand over to John to kick off the presentation. Awesome. Thanks, Renata. So good morning, good evening, and good afternoon, everyone. Thank you for, joining our webinar again today. For those of you who are returning here for maybe, potentially a fourth time, we appreciate you coming back and continue to join us in the series. As Ronna mentioned, today, we're gonna focus on how does governance and self-service work together and how do you look to drive a balance between those so you can enable those from a self-service perspective, but also keep your business and your data assets safe. So to kinda get this kicked off, the first thing we'll talk about is really that relationship between data governance and self-service. So I'd like to tell folks to think about this much like running a playground. Right? Your job is to make sure that everyone can enjoy themselves, but also to ensure that those who are on the playground hurt themselves or others. So how do we really drive this balance? So when we look at this, there's really kind of a almost a threefold kind of triangle, which you'll see here on the right side, where you're trying to balance self-service and governance together, and really the shared foundation is architecture and process. So the goal is how do we find a foundation where the architecture and processes we have build, guide our users, and guide our business on the right route. So to Renata's point, now the easiest path is also the right path for those users for them to achieve the outcomes they like to achieve. Now as part of doing this, you have to make sure that your data governance controls are very clearly defined, and that includes how those aligned to both internal controls, but also external regulations and policies. As you get those aligned, you need to figure out how you then to design that into the architecture, what we call architectural governance. Now importantly, as you start to look at how to do this, you need to be very clear on ensuring that the processes you put in place are applied evenly across all users in the organization. A very common theme that comes up is that there'll be a a, you know, very important business initiative, maybe a potential event that's happened that causes the business to ask, can we forego these policies this time? Because we need to get this done quickly. And that's a slippery slope to start doing. Because if you allow it for one time, you have to allow it multiple times potentially in the future, you'll continue to be asked. So you have to make sure it's uniformly applied. And as part of this, that narrative is that the greater good takes precedence. So So be ready to talk to your users about, well, from the greater good of the organization, protecting what we're doing, we have this kind of approach. That usually resonates much better than saying, well, thou shalt not do something without a reason behind it. Now importantly, to do any of this, you have to have overall visibility, observability into the environment. You can't really confidently reduce risk if you don't understand what's happening. And as part of that, Dataiku plays a huge role. You know, being a universally AI platform, it gives you the observability across the entire pipeline of analytics and every step that goes into those analytics models and AI outcomes as we covered in the first couple webinars of the series. So we wanna make sure that you focus on enabling the best user journey while also mitigating those risk through your observability. It's important and no valuable to lead with an automation first approach. If you can remove manual steps and reduce that kind of manual input, you'll likely have better alignment across your processes and better outcomes in terms of define defending your risk. And then finally, you wanna make sure that you're kinda teaching your data governance and applicable processes in tandem with self-service. So they should be taught together. If you have a separate data governance team and a separate self-service or enablement team, make sure they're working together to align that commentary and narrative across the organization. So now that we've talked a little bit about how we think about this relationship, how they start to come together, Let's really talk about how you start to support this outcome. So here at Dataiku, we use the terminology architectural governance, which is this idea of really, again, balancing architecture and process to help ensure that you're supporting both self-service and governance across the organization. And there's some premises behind this. If you think about an average day in your life or an average day for an employee, ultimately, the goal is to achieve the outcomes you want to achieve as fast and efficiently as possible. Right? We all have different things we want to do in our days. We all have different things we want to achieve. So that can actually be juxtaposed against the idea of governance, which is really focused on this idea of managing processes and, you know, derisking the environment, ensuring things were safe. And this can lead to kind of being doing these two ideas is really juxtaposed philosophies, ones that push against each other. So the goal here is really how do we make these complimentary and work together? Then once you see here in the middle of the slide are some examples of architectural governance being implemented by through Dataiku to help support what users do on a daily basis on the software as they develop their own data outcomes. So a simple example is like enforcing in database processing or containerized processing. Something that will happen in a self-service environment is that a user will start to work with a set of data. They may not know the background of how processing architecture works. And all of a sudden, maybe they run all the data through a particular server, compute engine, whatever that may be, and it can crash that process. So one way to avoid this is not make that decision at all for the user. Instead, preconfigure where the processing happens. Then when the user does the work, it's automatically taken care of. So, again, you're giving them an easier user journey, but you're also applying governance of potential spend as well as de risking your environment from instability. Another example is really defining certain connections you can make. So a common question I get when working with customers is, well, how do I assure that my data assets are safe, not being stored in environments they shouldn't be if users can connect to really any data in the company? One way to do this is to find clean areas where you know your datasets are appropriately managed from a control standpoint, then ensure your connectivity to those environments can only be done that way. So as an example, maybe have Dataiku connect only to your data lake environments or lake house environment, but maybe not connect to your ERPs. This helps to ensure that they're only connecting to a particular environment where that data should be stored and also keeps your ERPs from potentially being impacted by processing they were not expecting. Another good example is this idea of pre and post SQL statements. So within Dataiku, you can write these statements or inherently make them occur whenever a user decides to go to production. And what this would mean is, as an example from one of our customers, is that as you go to production, if these users are creating new datasets, you can ensure those datasets are loaded into your security paradigm, such as if you have an IDM system on the company. So by applying these kinds of statements, you again ensure the user is being applied to a secure environment, but they don't even know what's happening. You'd actually remove the name from the if you consider that. Few other examples here we'll cover, and these will go into a bit more later, but it's the idea of test driven development. So if you're familiar with the world of software, when we look at software test driven development, we look to write out certain checks that we need to meet before we go to production. Well, the same thing can be applied to data analytics. We'll look to define what things need to be met before that product goes to production to help ensure users are meeting those requirements. And we'll dive in a little bit more on the next slide. Another example of this, more towards the data science end of the world, is that you can enable users to install their own libraries, but you can also blacklist and white list libraries to either get more or less control. A good standard that I like to apply is to white list most libraries to be available, but maybe blacklist any of those that could have potential compliance on facts or those that may come up residual charges to act to them. And then finally, which I think is a excellent example of architectural governance, is what we call LM mesh here at Dataiku. And if you're not familiar with LM mesh, you can think about it almost like a routing paradigm, routing platform that sits between your users and their prompts, and then the back end LMs and agents that support that. And what you're able to do is actually route your traffic through this engine and ensure things are being managed from the cost perspective, that you have full traceability of where your data is going, control what elements and agents are being used, and also do things like extruding toxicity as well as other elements that you may not want within your prompt or responses. So this is a great example of setting the guardrails in place, the right architectural governance that gives the business the ability to connect the various AI assets, but to do no do so in a safe and controlled way across the organization. So as a basic model for how to get started in this, it's a pretty similar model to any type of control exercise. First, you wanna determine any external regulations or internal policies that apply to your data, especially in those that are involved AI regulations. These are moving very quickly today, so it's important to stay abreast of what's going on. You also wanna determine any additional internal outcomes or user behaviors that you wanna apply to your datasets. So for example, if you have a need to have all of your new data products documented, make sure that's built into your architecture and governance processes so users are doing that as part of the natural process flow of their work. You wanna make sure you brainstorm what controls can be used to ensure those, and importantly, those that can be done through architecture and automation. Your goal is to remove the need for humans to do these efforts and instead try that the system itself support it. Finally, you wanna score these controls against the level of ongoing automation, their effectiveness, and use of adherence for users, as well as your effort to implement. And, ultimately, what you're looking for are easy things to implement that'll help you get significant gains in how you govern your overall environment. Then finally, you wanna select these controls and look to implement them as part of your backlog. So taking this a little bit further and thinking specifically about the idea of release governance. So a very common conversation that comes up in these realms is how do I ensure users are meeting my best practices before they go to production? How do I govern this overall environment and help drive better data management, better security, and risk control? And, really, this also helps you think about things like how do you improve your cycle time? How do you help ensure you don't stifle innovation or frustrate your users? All these things kinda come together in this idea of how you do releases. If you spend too much time doing reviews and too many manual checks, you just may get frustrated not get to production. But at the same time, if you don't put enough controls in place, you may have data products going to production that could be risky for your organization. So, again, this is an idea of balance. And, really, at Dataiku, we have a couple, you know, particular architecture and product offerings we have that directly support these outcomes for the organization. First among these is the idea of Dataiku Govern, which you'll see here on the left side. And this is the idea of process governance. So when someone get looks to go to production, what checks and balances should happen? Who should review the data products? What are the levels of risk associated with that? How do you keep track of the objects tied to this particular data products? So what you'll see here on the left side are some recommendations for how to build these processes and a few questions you should ask. So first and foremost, you should be able to operationalize, you know, data and AI agents within your organization. As you've heard maybe previous sessions, if you've attended, part of this is defining what individuals you want to do, what kind of work within the organization as it relates to data and AI. That same rule applies here. You may have different processes depending on the type of user or persona that is going through governor looking to release a data product. Another thing to consider is, you know, what is that process that someone should go through when they look to release it? So how much oversight do you want? Does that oversight change? Similar to that is, does that process to operation as a data product change based on the persona, demand, or business unit? So, again, you may have certain personas that you're comfortable, say, automating your data engineering type projects, but you may have different personas you're comfortable automating, say, an AI agent. So, again, think about how those may differ, and they may cause you to have different flows or processes. Now importantly, if they're going to be reviews, who does those reviews? Do you have senior principal, say, data engineers or AI experts that will do that? Do you have lines of business who will look at these reviews? What are the right ways to provide those, checks and balances? Now are there any data product types that carry, you know, a low enough risk or similarly data product types that carry a high enough risk that you need to design a different process? The example I like to give from my own career, being in the aviation industry, if we had a data product that was tied to the idea of flight safety, that product is gonna have as much review as possible because that's paramount and the most importance within that industry. Similarly, if I'm releasing a data product that doesn't efficiency play, say within finance, maybe sales and marketing, then maybe that doesn't mean the same level of review. So maybe the first data product that's more critical, I have a number of steps and checks and balances and reviews to release that. Maybe for the second, maybe I have no checks and balances at all other than log in to the data product's been created and letting these go to production. And then finally, as you complete this process review, make sure you're considering if the process is really enabling speed as much as possible as well as abating risk. You'll find over time that you wanna change certain things to continue to try to get better and better at balancing those two items. Now I'm kind of flipping to the other side of the conversation here is the idea of technical release governance. So tying back to the previous slide, now do you have test driven development for data and analytics? This is where this can be applied within Dataiku. Now for us, we call this our project assessment tool, which allows us to assess projects and if they're meeting certain criteria as they go to production. So think of that like almost an auditing system. So as you think about this, one thing you want to consider is first, do you have technical standards that exist today, for your data accrue projects? And if not, what technical standards should exist in the future? And how's that change with AI agents? Again, this is something you wanna review consistently as governance policies change. Now do these technical standards change based on the persona domain or business unit? So again, do you have different technical standards for, say, your data science teams and projects versus maybe your self-service users within the business? Are there data products that currently meet these technical standards that you can promote directly to production and there's no additional checks? So are there certain data products that say, hey. We could just go straight to production. And then are there other ones that may have additional risks that maybe shouldn't go straight to production? And then finally, if you have actual data who process that currently meet this, can you use those to write the test initially? So if you have one that meets the specific requirements, can you take that example to write your test driven test? And then finally, you wanna take all that information and think about what technical standards can you look at to be checked for your test driven development. On the bottom here, I provide some simple examples of that. You may wanna check your code environments. So if you have different versions of Python or r that you're loading up, you may wanna ensure that what's going to production meets those particular requirements from a version standpoint. You may wanna ensure that certain libraries are only being used and checked for those when going to production. Similarly, you may wanna check for your project metadata. So if things have been fully documented, are they even available to users? And if you're in an environment with a non product production environment, you wanna make sure you wanna you may wanna make sure that those projects have been run within a non product environment to test to make sure you want the impact stability of your ecosystem. Now my favorite way to implement this is the idea that when a user goes to production, they click a button. The button goes through and checks, say, as all these things happen. So it's called a foot within Dataiku, and it confirms if each has been met or not. And what the user will get back is a printout that says, basically, you've met each of these or you failed this. If they met everything, they can go to production in thirty seconds. If not, they'll be instructed by what steps to take next to meet those criteria to go to production. So now that we shared some examples of architectural and release governance, I'm gonna pass it over to, Jacob here today, so our senior director for AI governance. He's gonna spend some time digging into how do we think about AI governance here at Dataiku, and then do a deeper example of how we use Dataiku to help enforce these principles with our customers. So, Jacob, over to you. Thank you very much. Hello, everybody. If I can just share my screen. Thank you. So thank you for the introduction. Hello, everybody. As mentioned, I'm gonna be discussing AI governance. So at Dataiku, when we talk about AI governance, we're talking about the orchestration and enforcement of rules, processes, and requirements that align AI initiatives with business risk and other objectives. When we talk to customers, organizations about AI governance, we tend to also talk about things like responsible AI. Responsible AI, if you're familiar, reflects principles. These have been kind of discussed at the global level for, since about 2018, 2019, if not earlier. And from our perspective, responsible AI is really about securing reliable, accountable, fair, transparent, and explainable models and data pipelines. Now it might be the case, and we're thinking about COEs, that in the context of an AI governance framework, a beautiful draft of a document has been produced. It's laid out a sequence of, processes and requirements aligned to a given framework, and everybody's happy they're done. But they are not done because for it to have any impact on the organization, it has to be meaningfully operationalized. You've just heard about some of the vehicles for operationalization, to the previous slides. But it's worthwhile saying that every time we're talking about AI governance, we're also talking about operationalization. So how are we enabling, through MLOps, smooth systematic operationalization of data projects across stacks while reflecting a governance process? Moving along. Saying AI governance is this concept is fine, and I if I walked away now, you'd think, okay. That's AI governance. Great. We can make that happen. But I don't think that's totally useful. I think I'd rather just walk through some of what I consider the foundations for AI governance. What are the pillars or bedrock upon which you would build out an AI governance approach, and its potential future implementation? So I call these kind of the readiness foundations. The first is, framework understanding. So you heard a little bit about this earlier. It's this idea of having a framework, a selective framework. It could be regulation. It could be internal policy, whatever, that you're basically pinning your governance approach to. So you'll note that this is presented on a spectrum. Each of their five foundations, each are presented on a spectrum. On the left, you see kind of a low, maturity. On the hot on the right side, you see the high maturity kind of side of the spectrum. So with respect to frameworks or framework understanding, you might imagine an organization kind of a lower maturity, but just have zero awareness of frameworks that are available to them or being considered. Or maybe there's just none that exists or being that are being kind of, like, framed in the company. It's something that they wanna aspire to. And that's okay. It's a journey. On the other end of the spectrum is high maturity. So this is where the a framework has been selected or it's been evolved, and there's a complete understanding of the requirements kind of embedded in that framework. The next foundation is leadership. So from our experience, we see leadership as kind of a critical playing a critical role here, pushing forward governance initiatives. So on the left hand side, low maturity, you see there's situations where there's kind of no leadership awareness. There's no prioritization around governance. There's no sponsorship. Conversely, at the higher maturity end, there's a sponsor. There's a strategy around AI governance, and there's a rollout plan. Now the next foundation is responsibilities. So, unsurprisingly, on the left hand side, teams might be totally unaware or oblivious about AI governance. And on the right hand side, much more mature, we have RACI that's well developed, and defined, and there are key owners of different kind of elements of the governance approach, in place. People understand their function. Are they reviewers? Are they signing off on products before they're going to production? Are they defining the governance process, for example? The next is, unsurprisingly, AI governance itself. Remember, this is rules, requirements, and processes. This brings together the framework. It is kind of jettisoned by the leadership sponsorship, and it is considering the responsibilities and kind of pushing them into a a repeatable and systematic process that could be implemented in a company. Left hand side, there's two elements here that I would consider lower maturity. One is that maybe there's absolutely no governance approach that's been developed or considered, which is kind of representative of that left hand column. The other kind of way to think about low maturity here is that you have no kind of nominated framework, no leadership, but teams are bubbling up with ideas independently. And while this shows great initiative, and it's kind of inspiring to think that people are taking greater care, with how they develop and put, put AI systems into production, from the perspective of moving right where it across all the kind of foundations, it does introduce some challenges. So, for example, a company that maybe down the line has a leader who says this is the framework. We're gonna push it forward. From a an operationalization perspective, there's this alignment and kind of, disentangling that has to happen where there are highly varied or variegated approaches to governance that are being kind of operationalized. The more mature end of the spectrum, again, unsurprisingly, policies and processes are implemented purposefully and coherently aligned to the other foundations above. The final foundation that's really important from our perspective is tooling, which I consider a vehicle for systematic operationalization of AI governance. If we think about, the aspiration about AI governance, coherence and repeatability is really important. You can do this in different ways. You could have really kind of, I don't know, managers who are just really attuned to it and really involved in their staff's workings, but this is not scalable. And so for my perspective, tooling kind of takes that over, insofar as it puts guardrails around how what information is expected and, push forward from a government's perspective, with reviews and sign off processes that gate deployment as the vehicle for with by which, that tooling or the incorporation of important metadata, is reassured and validated. So I won't bother speaking to the left and right hand columns if it gets self evident, very limited versus toolings used. So these are the foundations. What does it look like more practically? I'll take you on a little bit of a journey. This is a highly stylized example of what, AI governance reflecting those foundation might look like. So we're hopefully all familiar with this kind of virtuous virtuous figure eight. We're in a world of building and deploying. In this world, we might have requests for AI projects coming out of different parts of the business. So we have a business lead who might come out and say, I need this system, and I need it, like, tomorrow. But with the governance framework in place, one that sets expectations around kind of risk tolerances, around what's kind of legal, illegal, whatever other kind of variations of, parameters of interest that framework might represent, that a governance lead might come in and begin to qualify that proposal or that request. Making a decision, yes, we should allocate resource to it because it passes our kind of frameworks, expectations, or thresholds. That resource will, as a data scientist, do some development work, push to deployment. But before deployment, we wanna ensure that what's been developed is aligned to the framework's requirements. So, again, this might reflect different things, and it might reflect some of the things that Jonathan was talking about. Things like risk management, perhaps things around value, perhaps things about, different legal frameworks, whether it's European Union, EU act, things like, data protection considerations, whatever. Now with an analytics lead coming in perhaps from a more technical perspective and a governance manager coming in from kind of a pure governance framework perspective, they can do their review and they can provide their sign off on what's been produced, ensuring that operations need ensuring that everything is kind of in place for that system to be operationalized, their validation being a critical part here, from the perspective of security and reliability. And then in the deployment space, we have MLOps leads who need a bird's eye view of everything that's in development and deployment. Head of data science will want an understanding of, again, the same kind of portfolio oversight, but perhaps looking at from through different lenses, perhaps things like, what's in development today? What's in production today? How can I manage my resources? What's my risk, exposure across the the organization from the perspective of data data products or AI systems? Then we could return to our MLOps lead and our governance lead. An MLOps lead will need that oversight in order to make assessments about whether or not these models or AI systems are performing. And part of that exercise is to feedback ultimately to the data scientist. Things need to be updated, changed, etcetera. The governance manager here needs to make sure that, what's been put into production is continuing to align to the governance framework. So, for example, asking and answering a question, this thing has been deployed. It met our risk tolerances at the outset, but since it's in production, we've got x y z complaints. Perhaps our risk assessment at point of deployment, needs to be reconsidered. And if so, what do we do about it? So that's a very high level kind of notion of what governance could look like. It brings some complexity to the organization, but I think tooling plays a critical role in making sure that that complexity is smoothed over. Tooling. Set myself up. So this is govern. I'm gonna show you a few screenshots and walk you through them. This is the govern node. This is the kind of discrete space in data on Google where you can execute your process governance. I have different paths here. I'll show you a couple paths over the next slides, but just to give you kind of a high level for this slide. I have my governable items. This is effectively my inbox. So every single project that's created across my ecosystem arrives in my governable items and can be governed according to the framework that's appropriate. I have different kinds of registries. I've got a model registry bundle, project registry, which is represented by government projects. Each of these tells me the governance status, deployment status of my data products. I have a business initiatives when, space. This allows me to group projects by area of the business. So remember I talked about the data the head of data science needing kind of a a bird's eye view from a portfolio management perspective. Here we might have an HR lead who just needs kind of a bird's eye view of all the kind of, data products being produced in their remit and that are in production in their remit. You get the idea. What I didn't mention is the GenAI registry. So this is available to our to our advanced government users. This allows us to get insight into where agents, augmented LLMs, fine tune LLMs are being used across projects and governing those objects, which I'll show you in a moment. So how do you align to specific frameworks? I kind of alluded to this. I've in following the example I gave you about kind of a request for a product, being made by a business user and a give governance lead coming in and qualifying that, I kinda wanted to show you what that looks like. So this is, our European Union AI act of readiness solution, part of it. We have built built what we call a pre assessment. You're seeing here, I'm making a request for a fraud agent. In my pre assessment, I'm filling out relevant information about the according to the qualification exercise. So for instance, what you don't see on screen is I'm dent I'm identifying that this use case will be operationalized in the EU. It meets the definition of an AI system. I can specify the intended purpose or the scope of this, AI system, which is critical for, like, the whole governance exercise. Following that, I can begin to qualify the risk level. And you can imagine qualifying against whatever kind of, parameters are important to your governance framework. This might be cost value perspectives. It might if, for example, if something is anticipated to exceed x amount of money in terms of cost but be lower than y amount of money in terms of value, we just won't do it. So for the purposes of the exercise I'm showing you here, it's against risk tiers. I'm determining this is a high risk system, and then I'm able to begin giving further context about the nature of the risk of this system. So for instance, I built out a fraud agent risk card. You see that here, risk one. I can create as many risks as I like. It's a becomes a repository of risks that are useful for my assessment before deployment. So I can ensure that all the risks we've identified over the course of development, but also governance, are mitigated and addressed. Finally, I have the control to make a decision about whether or not I wanna put this into production or development. So this sign off, basically, the person signing off, perhaps it's the, analytics lead, the manager of the PIRD, the data scientist who would be working on this. Perhaps it's somebody else specific in a from a governance perspective, can come in and look at the data captured above, make a decision. There I can tolerate the risks. We can we're happy to push forward with this. Let me sign off on it and allocate resource. Now what does it look like once something is in development? So I showed I told you earlier about the governable items. So now I've had my data scientist that created the fraud agent. You can see it at the bottom row under projects. So this becomes a governable item. I can now click that blue box on the right, select the right framework, and begin to govern this alongside the development. I can govern the objects that sit within it. So, for example, bundles. If you're unfamiliar with bundles, this is the object I'll put into production that includes the agent, that includes any data, and the other models. And then I can govern, in this scenario, relevant agents. What does this look like kind of end to end? I mean, this is a very truncated form. This is my project governance. This is my fraud agent project. I can see that I've completed my pre assessment. I can see my v one bundle that I need to govern. I can see on the left hand side by sequence of steps. The first one is establishing metrics and thresholds. This is specific to the EU AI act. I can see model governance. This is where I dive deeper into my models that are active in or that are part of this bundle, and then I govern my bundle itself. I won't go through all of it. I'll start just with the agent. Here, I can see that I want to understand what's going into this agent, and I wanna make sure that it's aligning to my governance frameworks kind of parameters. I can target or pick can pinpoint which model version is being used to power this agent. I've chosen GPT four o. I can refer to the connection through which that LLM is being operationalized. This is a Dataiku concept that I am not gifted enough to summarize in a short amount of time. That connection at the admin settings, I can do things like program guardrails, which you see on the screen, toxicity detection, PII, forbidden terms, and some examples. I can also specify in relation to this specific agent, oversight mechanisms, agent con constraints. All of this becomes very important information to the people reviewing and signing off on production. Right? Because we wanna make sure that this is the right model version for this given agent. Are there any risks associated with this model version in the context of something like a fraud agent? I wanna make sure that we're using the right connection, that the right permissions are made available to everybody who needs to use the system, and so on and so on. So it's a validation exercise. Finally, I'll move on to my bundle. I'm happy with my my agent. I've signed off on it. And now my bundle governance, I will not go through it in detail. The first thing I wanna do is I wanna confirm that the thing that's being built is actually aligned to the intended purpose we scoped. So isn't the same thing? And if it's not the same thing, we might need to review it again. In this scenario, we'll say it is. I wanna confirm my intended purpose. And then I can also begin building out my risk profile. So before I started with this one risk, now I have two. Perhaps the second one was developed imputed following my agent governance and agent development. And at this point, in my bundle governance exercise, I'm getting ready for product sign off, which allows for production. Here, I can validate that the, the risks have been mitigated. I can explain the mitigations we've undertaken. I can give confidence to everybody who, is part of the governance exercise, but also the business community who will be using this system, that it's safe to use, that it's aligned to our expectations. And this is what that sign off looks like. I've got I can bring in different actors who I think are relevant, maybe risking compliance, maybe the business team who made the request, and I can have a final approver who has that power to kind of release the gates to deployment. The final thing is just to show that I maintain information about the deployment environment. So I can go there if I ever need to, from govern. That is it for me. I think to kind of quickly wrap up, I just wanna highlight that we are kind of this is part four out of six. There's more to come. Please join us for those remaining two, but also if you'd like to catch up on the previous sessions, feel free to via this link. Thank you. Awesome. Thanks, Jacob. So we'll pause here for a little bit and do some q and a. I'm seeing a number of questions, kind of flowing into the, to the q and a chat here. So, Jacob, if you don't mind, can I, can I share your screen? Yes. Awesome. Thank you. Perfect. Okay. So I'm gonna try to hit a couple questions at once because we've gotten a series on that I think are somewhat related to each other. So I'm gonna go ahead and bring up, the slide that you see here. So we'll go ahead and jump into this a little bit. Just to read off a few of the questions we've received. So from, from Stephanie first, in the context of the data to LM mesh, how can we architect governance to monitor for prompt toxicity, quality, or cost overruns without blocking access to nonapproved LMs entirely? And I also wanna answer this in, you know, cover with a couple other questions we received. So from Salvador, how does this improve on building an ethical governance trained AI agent into your system? And then from, ROC, how are automated ethical or moral risks assessed? So what you'll see here on screen is an example of our l and mesh offering here at Dataiku. And I would say that for at least all three of those questions, this is how we start to think about how do we do this in a more, distributed way. Right? So for the series, we've been focusing on self-service, or how do we empower the business to build their own data outcomes? Of course, it applies to AI agents and working with LLMs. And what we do with LLMs is try to find ways to apply the appropriate guardrails to enable that activity in a safe and governed way, so in line with the theme of this series. So to kinda touch to to Stephanie's question first, the idea of how do we block no. Not block access to, you know, nonapproved elements entirely. So here's the idea. Right? If you see at the bottom, we have various, services that we can get to from the element standpoint. Right? So we've got our computing. We've got our LMA PI services, self hosted LMS, as well as our vector stores. And then we have our generative AI applications here at the top. In the middle here, we really have what LMS provides, which is that really that routing and orchestration. So as you can imagine, if your goal is to only allow certain LMS, even potentially for groups or users, you actually define which LMs can be accessed by those groups. So if you can imagine security groups being applied to particular paths to the LM services down below, that's how you start to do that. So then as an internal team or COE, you can actively define what does it actually look like from a, from a utilization standpoint. Right? What can users use and what can't they use? And similarly tied to that, we have to focus on how do we manage things like toxicity, quality, or cost overruns. And, really, all those can also be managed at that layer. So So if I'm looking for toxicity, now this may be dependent on your organization industry, but we can put in what terms we wanna look for that may be toxic and define, hey. These may be toxic terms that cannot be given in a particular response. Similarly, if I'm looking at things like our cost overruns, we're able to use what's called cost guard within LMSH that actually tracks the amount of, expense being used from each LMS standpoint and has the ability to even put up direct blocker that says, hey. Stop using at this point or just have a friendly reminder saying, hey. You're getting to a certain amount of consumption spend. Please be aware. So now we're also getting additional direction to our users so they don't accidentally go through it and blow up the budget. And, similarly, the same idea applies to quality. So if you see at the bottom right here about enriching queries and responses, the cool thing that we do within NLM mesh is we also check for really that faithfulness and relevance. Right? So faithfulness is really saying, hey. How close is the response being provided to the actual source material, the data that that's coming from? Similarly, relevance discusses how close is the actual response being provided aligned with the prompt that was originally received. So in both these scenarios, you actually use an additional agent that will go through and actually check these elements specifically to tell you if you're closer. So if you can think about the agent or element receiving the prompt and having additional agents checking for this, you're gonna have this process where they're working together to help better inform and ensure you're meeting this kind of faithfulness and relevance type items. So kind of tying to the question related to, obviously, of ROC, how are automated ethical or moral risk assessed? I think this is how you start to do that. You start to look at how do you define what is an ethical or moral risk, some more of your toxicity. Right? And you also start to see, okay, is my underlying data aligned with what I will want to represent from an ethical or morality standpoint? Do I have anything in that that would cause me to have inappropriate answers? You can start to check that further by having those faithfulness and relevance checks directly within the flow of what we're doing in LMS. So that's how you start to see that come together. And over time, your system's gonna get smarter more and more and more from the interactions you have with it. And those AI agents are checking for that faithfulness and relevance. They're gonna give you better and better answers. And I think kind of finally tying back to Salvador's questions. So how does this improve on building an ethical governance trained AI agent in your system? I think, again, it's a very similar idea. If I have this agent, and over time, I want my business to start working on building this out, by putting these guardrails in, I can start to enforce organization wide or department type of models or what we accept from a risk standpoint. They can then guide these users to ensure they don't accidentally build the wrong thing or build something that's maybe not ethically trained. So that's the way I would recommend thinking about all this. And then I also see one more question from Salvador. So he also clarifies, I mean, GPDR, CCPA, and even HIPAA. So I think the same idea applies. Kinda going to what Jacob was talking about. Right? You could look at the EU AI act and how we check for all that within the govern type process. So you could also check for GPDR, CCPA, HIPAA as well across all those. In my background experience, I tend to think about things like export control or country related regulations, but the same thing applies across all. You can apply the human process to check that. But then on the opposite side, you can also train how you're actually checking for faithfulness and relevance. Train those models so they can also check to make sure you're not violating, you know, GDPR, not violating CCPA. So, basically, you build the system to further look for what will be a challenges for that and to build into it. Now, of course, all those different frameworks also have requirements around system security and things like that. That's not more of an automated AI approach. That's more of the actual systems, security and architecture. Jacob, did you have anything you want to add related to any of those questions? I think we have at least one more in here. But anything on those items before I jump to that one? No. I enjoyed your responses. The the only thing that I'm reflecting on is, okay about this. Let me continue reflecting, and I'll wait to you. If we're if we're nearly done, okay. But if we have a little bit more time, I'll continue thinking about it. Absolutely. So, yeah, the other question I've received, which is from from Anata. Can you share how test driven deployment through the Dataiku path tool helps make governance seamless at the automation stage? Yes. So something we see, pretty routinely across customers, right, is this idea of when you go to go to automation or go to production. Right? So you're going from something you've designed in a non problem environment or what data could cause our designer node, and you wanna go to automation or production, right, or go to a production environment. So what we're trying to do here is enforce particular standards or best practices as they relate to what we want our production data products, certainly, I solutions to look like. So that's what you're really checking through that kind of path process out test driven development. Right? So everything from we wanna ensure certain libraries to we wanna ensure that you run dev test processes to your following certain standards. All those things kinda come to that. Now what's important about that is that in most organizations, when you wanna go to production and you're a business user, that usually means that you have to hand off your project to an IT or data team who then picks that up, goes through, and maybe does additional work and then takes it to production. For many companies, this can be, you know, a multi week, multi month long process. From my own experience, this used to be a sixteen week long process in my former work. So when you look at that, right, that's very frustrating for any user. They don't wanna wait four months or sixteen weeks to get something to production. So what we try to do is instead of having that human element and doing those manual checks, we wanna automate that. That way, we're not waiting on those human kind of timeline to do it. We instead have the system do it. So then when that user decides they wanna go to production, instead of handing off that data accrue project to a team to check, do all the different analysis, and maybe make changes to go there, we incentive that used to go directly to the system, submit the request to go to automation. And through the checks we've written through the path tool, we actually go through and check for each of those items to make sure they've been met. If they've all been met, that user can go to production and say two months. They don't need to wait on a sixteen week process of checks and balances. If they don't meet everything, then they get a response back and they can take action to meet that. And what's empowering about that for the user is that they have agency. They're not waiting on a particular team or system to tell them what to do. They're getting back an immediate response and or immediate action for what they can do to proceed further. Now, of course, this comes with some checks and balances. If you have really critical analytics, so going back to my example of flight safety, then you probably don't want that to just be automated. You do want some additional looking into that by your more senior team members. However, if it's things that don't have a huge risk or criticality, this is a great way to enable that kind of standardization while also enabling freedom to go to production on your end. And I think with that, that looks like all the questions we have. If there are any other questions, please feel free to, to add them in. Otherwise, Jake, if there's anything else you wanna add, otherwise, we'll go ahead and close out here for the session. I think we can close out, but I'm, ROC and Salvador, you asked me questions that I've been thinking about a lot. So I'll I'll say this much. This idea of agent based, ethical and moral assessments or using some kind of, generative AI model to do that work. I'm personally they hire me because I'm cautious for this role. So I'm personally very cautious about executing something like that, not least from a maintenance perspective and kind of like a reliability perspective, not, especially consideration with what, data is feeding that and what how are those models, being trained continually trained, And are they behaving the ways you originally outlined? So there's this level of having to govern those things that you might as well have just governed the original objects that you were, you know, distributing them to, if I'm understanding your questions correctly. Something I think a lot about, something that I'm very cautious about. Awesome. K. Well, I don't see any of the questions here. Merna, do you wanna go ahead and, take a step? So if there are no additional questions, I guess we can go ahead and wrap up today's session. Thank you so much, John and Jacob, for your insight on what it takes to scale governance and self-service side by side. I think you both shared some powerful ways. You know, these are making governance a part of the everyday workflow instead of being a blocker to it. And I think that there was a lot to take away from what you both shared today. And, of course, always a pleasure having the both of you here. So thank you again. And for the audience, we look forward to seeing you all in our next webinar. Have a great rest of your day, everybody.