Yeah. Thanks, Josh. Very kind of you. And, yeah, it's been a great experience working with Medigap. But, yeah, also looking forward to the next things that I'm I'll be working on. That said, you know, I'm definitely still around on the Slack, and I, you know, intend to, you know, help maintain when I can some of these projects that I've been developing here. So, yeah, I'll be talking about one of those that's I've been working on and off on for the last year or so in my time. Let me share my screen. Maybe this looks alright. Okay. Can you guys see this presentation? I'm gonna show the right screen, I guess, is the question. Okay. And I I won't be able to see the chat very easily in this view, but, yeah, feel free to chime in if you have any questions or thoughts as I'm as I'm going here. So, again, my name is Lucia, and today I'll be talking about the DAO governance services project that I've been working on with Medica. I think the first big question here, and I saw this coming up in the before this this seminar, is what is a governance service? This is a term that, you know, isn't particularly common right now. In fact, it was sort of put forth and developed by Zargam here in the the chat and also Kelsey Navan in a paper that maybe I'll link in the chat afterwards, so once I I get a chance. But the overall concept here is that the governance surface of an organization, specifically, is the set of available actions through which it can adapt itself. So in sort of the context of DAO specifically, you can think of this as maybe, like, the set of parameters through which an organization's code could be modified. So in analogy to, for example, like, you know, legal institutions, you can also think of this as sort of like a legislative process through which policy is made, where, you know, there's a set of accepted actions through which, you know, policy or laws can be modified. And there's a sort of codification of that process, what actions are acceptable, what are the terms of of of those actions, that kind of thing. This term was also developed sort of in reference to the term control service and feedback control systems where, you know, if a control surface is to be exercised pursuant to a particular organization's purpose, you want to think about members of that organization as the controllers. And keep in mind that these actions that are being undertaken by the members are specifically to sort of allow the organization to fulfill its goals, whether that means adapting itself to make sure that it can keep fulfilling its goals, you know, as if environment changes or as the goals themselves are are changing. That's sort of the purpose of the government service. I want to also point out that this term does not include sort of the actual history of actions that are undertaken through that surface. So this is a definition sort of a structural term of, like, what exactly is the surface through which members can then interact and then actually perform actions. But the the term itself does not encompass sort of the entire history of actions undertaken through the service. That becomes important, excuse me, in in DAO specifically where, you know, the activity that you see on chain that is undertaken through a DOW smart contract is basically the actions that are taken through the governance service. So the the the history of what you can actually see on chain is not the governance service itself, but smart contract itself is. So, yeah, just to to clarify, for DAO specifically, these actions that you can undertake to basically adapt the organization that is the DAO are often circumscribed circumscribed by smart contract. So this contains a set of parameters and the mechanism for modifying these parameters. So for DAO, that might include things like membership roles and permissions, proposal creation and management, voting systems, dispute resolution, as well as settings that affect sort of high level economic structure or behavior incentives for for what the DAO's purpose is. We're I'm not gonna go into all the detail that's shown in the slide here, but this is just an example for a relatively simple DAO contract structure. So here, for example, are some of the sort of member properties and types of actions that members can undertake which affect the DAO. So sort of a a high level definition of of a governance surface for for a DAO that might use this DAO factory contract. So for example, a member has shares that allow it allow them to vote and loot, which is their contribution to the treasury. They can delegate votes on their address. And then if they are guild kicked, which basically just means, you know, removed from from the the DAO, the member can be jailed. Actions that member is gonna undertake is basically, you know, redeem the redeem their loot from the pool of the treasury. They can withdraw balance. They can collect tokens, and they can also view the state of the the current domed contracts. And then there's also specific parameters defining what constitutes a proposal that someone can make. So that's sort of a a key action within this governance surface is that a member can define a proposal, which can basically alter the state of the organization. So here, for example, there's some kinds of changes that can be made and some basic description of, like, what are the constraints of this action as defined by the code. I also wanna clarify that I think a lot of emphasis gets put on DAO smart contracts as sort of the the end all, be all of, like, what constitutes the DAO. And, of course, we all know that isn't really true. I mean, a lot of deliberation and decision making happens outside of the the confines of this smart contract. So for this the purpose of this talk, I'm I'm focusing only on what can be clearly extracted from code, but that definitely is not the entirety of the the full governance surface of the DAO. So, again, just continuing this example really quickly. We can see thinking of the the governance surface as a set of parameters as well as the set of actions that can change those parameters. Here's just an example of of some kinds of parameters defining the DAO that can be defined for a Moloch DAO. So there's a list of initial shareholders that are present at the time of the DAO's creation, the approved tokens that can be held at the treasury, parameters relating to how the DAO can actually or how how members can submit proposals throughout the through the DAO. So things like how long is the voting period? What is the proposal deposit that's required to be able to actually propose a yeah. Make a proposal. That kind of thing. So so, you know, I I'm not expecting you all to, you know, memorize this example, but I just wanted to give a sense of what kinds of parameters and actions might be defined for Dao specifically. Any questions so far? I've been running kind of fast here. Okay. If there's something I'd chat, someone please let me know because I can't see it right now. But now I'll proceed. So what can we actually do with the governance service? I think this is the big question that's been sort of motivating this project, which does not actually sort of answer any of these questions directly, but it does create a tool to facilitate answering these questions. One of these might be mapping the space overall of of DAO contracts. I mean, that's something that you know, there's a huge amount of different approaches to actually defining a DAO in code. And this is a tool that can help sort of, like, sift through what exactly is going on in there in a more programmatic way. So for example or, you know, using that kind of information, you might be able to, for example, develop a data driven fine grained representation of computational governance or develop a new model for DAWs using that information. This could also support standards creation. This is something we've talked about with the DAWSTAR standard. Could also inform sort of front end development for actually end user governance design interfaces. It could, of course, be very useful for conducting fundamental research, which is the primary aim of Medigos. So this is something that building off of Zargham and Kelsey Nabin's paper, we could, for example, investigate the relationship between the the size of a governance surface, however you might choose to define that, and, basically, the trade off between the resilency and robustness of that organization based on based on that. So trying to understand, basically, like, is there some sort of optimal control surface given a particular organization's goals that will allow it to adapt while still meeting its its goals, that kind of thing. Another potential use case for for a tool that can, you know, help understand the government surface is to perform audits and forensic investigation of DaaS. I think that's something that has has gained some traction in the last six months or so. And a lot of it often has to be done sort of by hand, you know, just kinda combing through the code and through documentation. So this could maybe help automate some of the smart contract inspection that is undertaken in in governance audits. Sort of comparable to current contract audits that are focused on security, this would be sort of focused on governance security, so to speak. And one last sort of moonshot kind of direction is to predict our performance. Potentially, you could build a a whole sort of data pipeline and, you know, add some ML in there and be able to analyze, predict, or even optimize governance in DAOs with respect to some list of target indicators using the the the data sort of the structure of the DAO as defined through this governance surface and then, you know, probably using some of the history of of actions that are taken through that governance service. So these are some of the ideas we've had about what can be done, you know, using the governance services identified for DAOs. So the next question, of course, was how do we go about actually finding those and and sort of extracting useful information from them? So the DAO governance service project within MediGov has been a project to develop a tool for analyzing DAO smart contracts through this lens of the governance service. So the main sort of deliverable that's come out of this is a GitHub repo that contains the code to do this as well as a preliminary dataset that's actually in GoofBase that contains the results of running this code on a number of major smart contracts. So I think after this, I'll I'll put a link in the chat to some of these various things. Yeah. The the repo, the datasets, as well as, talking to Kelsey's paper, defining this governance, surface concept more more thoroughly. Any any questions so far? After this, I was thinking to basically just give an overview of what the repository actually does, like, what you can do with the code that I wrote, and then sort of walk through an example Jupyter notebook showing what kinds of very simple kind of summary, analyses you can do with the information from that. K. I will proceed then. Let me start here, I guess. So right now, we're on the medical fork of the repo that I've been working on. I'm thinking, you know, for the purpose of longevity, this can be sort of the the new main version of this repository that people might want to add on to as they hopefully continue developing this kind. So in this repository, the the sort of tool that I've developed has one main okay. Let let me back up here a bit. So so, basically, what this can do is collect the parameters and functions that define the governance surface into a series of linked objects and tables, including metadata about who is allowed to view a parameter or perform an action and keyword labels based on the variable names and plain text comments and code. So there's a a few steps that allow this to happen. The first step is to basically find the URL for some GitHub repo that contains some contracts that you want to see. This could also include, for example, you know, even if the developers of a smart contract, for example, like a DAO factory contract, like, MolotDAO. If it's not on GitHub, you would have to maybe, you know, download the the the code from where you see it on Ethereum and then sort of, like, save it into a GitHub repo. But, generally, this can take any GitHub repo that contains smart contracts, extract all of the the relevant smart contracts. You can sort of filter out anything that's maybe irrelevant to your analysis or what what you're interested in specifically. And then using a solidity parser library, basically, extract out the using the abstract syntax tree, which is basically just kind of, like, you know, how you can walk through a piece of code based on, you know, where an contract is defined, where the functions within that contract are defined, that kind of thing. Basically, collect all of the objects and their parameters that are defined within a smart contract. So in this case, that includes the actual contract and function definitions where a function, in this case, is an action that a member can undertake through that smart contract. It includes state variables or other arguments for the state of the contract and any arguments that need to be provided to actually perform an action. It includes any kinds of, like, enums or structs or modifiers, which define the constraints around those actions. So all of that can be sort of extracted using the solidity parser and then sort of saved into a data model that I've defined, basically, to try and pull out what's relevant to this concept of governance surfaces surfaces specifically. The next step after that is to try and annotate the parameters that are defined and the the the functions that are defined with comments in the code. So, you know, for all that, ideally, all code would be sort of self documenting, and you can clearly understand what it's supposed to do and why it's doing it just for reading the code itself. You know, that's often not the case. So to try and sort of help the process of understanding, you know, what a particular parameter is is intended to do, I've also written sort of a a helper function that pulls out any comments associated with a particular parameter. So, basically, just, you know, in the code, someone might have written inline comments or docstring, and it sort of pulls those out and attaches attaches them to the the model the the object for that particular parameter or function. And then finally, to try and make it easier to do some kind of, like, aggregate analysis on this governance surface that that is being pulled out. This code labels each object or parameter based on the keywords that are actually found in the name or in the associated comments. So, for example, a function that's called create proposal would be flagged with the proposal label so that anything that's related to, for example, voting also gets added to the the proposal or voting label. And then you can sort of filter any of that all the objects that you've collected by things related to proposals. Right now, the way that this is being done is just a very simple keyword search. There's nothing fancy going on in there at all. So I'm thinking that a really useful future direction for this work would be to incorporate some, you know, NLP or some other kind of, like, more some some other kind of deeper kind of text analysis to, for example, incorporate documentation also, like, you know, link where the the documentation to the code is to try and actually, you know, add a little bit more depth to how this and accuracy to to how the objects are being labeled. Yeah. So, again, high level. There's sort of two kinds of features that are being extracted from this from a particular smart contract to define the governance service. One of them is is an object, which is defined as, you know, an action that can be undertaken or the contract itself and its associated state. And then the parameters which actually allow you know, define what it what what the define the action that's being undertaken or otherwise define the properties of the the contract. So that's sort of the the high level overview of the tool that I've built here. Maybe one useful thing to see next is some of the examples in Airtable of actually running this on a lot of smart contracts. So let me here to GoVase. So in go base, which hopefully you've all heard of and seen before, we have two tables that define the linked objects and parameters for a whole range of DAO factory contracts. So this includes things like, MolokDAO, like Aragon, Colony, etcetera. So, basically, this means that, given a URL for the, the the GitHub repository containing that code, which can also be, by the way, like, a specific, you know, release ID and not necessarily just, like, the main branches as it currently stands. So if you wanna see, you know, a particular version that was deployed at some date and time, you can do that. And, basically, trying to extract all of the I'm trying to get this bigger. The top level contracts that were defined within the sort of network of smart contracts since, you know, a repository containing the definition of of a DAO might contain more than one more than a single file. So you have to run through a bunch of different files and sort of link together what the what's related to what there. So maybe the easiest thing to do here is to, for example, show Probably should have filtered this earlier to make this a little bit easier to see. But for example yeah. So for example, here, we can see that different kinds of proposal states, for example. So some a member submits a proposal, and then it goes through a defined process for, you know, how long it's open for voting, the evaluation period for, you know, actually, you know, determining whether the proposal should pass, the execution period where the proposal actually gets, executed, that kind of thing. So we can compare, for example, what this kind of set of actions looks like across different factory contracts. So for example, in, you know, governor bravo, you have this series of possible states that a proposal might be in. So you can see that, you know, there's a there's a sort of this is the the defined series of sequence of events that happens when a proposal gets submitted versus in OpenLaw where, you know, it's either it either exists, it's been sponsored, or it's been processed, and you can't actually tell necessarily from the way that OpenBot is actually storing its or Tribute is storing its information, whether it's been passed in this case. So there, you can also sort of see differences in, I guess, the overall structure of this governance service, sort of what the user experience is based on what they're able to to see about the the smart contracts and and the state of the the smart contract in any particular point. You can also see, for example, proposal actions. We can one thing you'll see here is that oftentimes, it can be a little bit difficult to understand exactly what does what since it pulls in a lot of, you know, different versions of a smart contract. So for example, this is, I think, one limitation of this project as it is right now that I think could be easily addressed in not easily, but it can be addressed in further developments. Where right now, I've mostly designed this to pull in the the factory contract repositories where this is the the sort of full set of possible configurations or, you know, building blocks to define a particular configuration by a particular DAO. So in this case, it's pulling in a lot of different configurations that maybe can't all exist together at the same time. So I think using this for, like, a particular instance of a DAO to to understand its particular, you know, configuration that's been defined, You know, doing doing that as as needed in, like, sort of the the, for example, the DAO auditing kind of context, I think, will reduce the the existence of these kinds of, for example, duplicate parameters that you see here. Anyway, so as you can see, it's easy to pull in a lot of data from a lot of different smart contracts. But even here, where we've tried to for example, I'm looking right now at things that I that were labeled automatically by proposal. There's still a ton of stuff to to look through, and it's not obvious how it all relates to each other. So one thing that we could do is try and look through it using a Jupyter Notebook. So, yeah, here's an example that I ran for just the MolokDAO factory contract. So this was, you know, taking the the GitHub repo for MolokDAO, loading all the results, you know, running the the tool on it to basically create, you know, two CSV files, one for the the table of objects and one for the table of parameters, and then import those CSV files into this Jupyter Notebook to see what's in them. So we see that we've defined a hopefully kind of unique identifier for each object that helps us link which parameters, for example, which arguments to a function are linked to which function. So, you know, which actions what kinds of, you know, parameters are required to define a a valid action and through this governance surface, as well as some sort of metadata about a particular you know, for example, the the submit proposal event definition. It's not a very good example either. Sorry. But, basically, you can see that we can collect what type of action or property of the DAO contract this is. We can understand which other contracts it depends on. We can see what modifiers are applied to, for example, a function. One thing that is possible through Solidity contracts is to define basically, permissions on who is allowed to call a particular function. So that's sort of a a constraint on actions that can be taken. That is part of the definition of the government service where, for example, you know, only certain only members of a DAO can call a function, for example. So it checks that the address that is calling a function actually, you know, owns tokens of the DAO, for example. So it's collecting this kind of metadata that's defined within the smart contract code. It's collecting metadata relating to the comments that were actually in the the docstring for the code or an inline comments next to a parameter definition, for example. And then just some other metadata about, you know, when did we collect this information, you know, which URL is this from, and then collecting the parameter names that are defined for that object. So this is looking at the table of, for example, functions, contract definitions, modified definitions, etcetera. And then it also includes what labels have been attached to these objects based on that keyword search of the name of the objects and any comments associated with it. So looking through it, we see, for example, that we've found 14 objects that were maybe related to membership, 14 may 29 may be related to proposals. You can see that in graphical form. You can see that there are, you know, a lot of function definitions, but only a few contract definitions. And this is all sort of, like, one particular way to sort of quantify this overall sort of shape or size of the government service. You know, it's not necessarily useful without a lot of context and a lot of, you know, qualifiers on how exactly you want to use that information. But this is just a demonstration of one particular way you might want to sort of, you know, aggregate information about a smart contract in a way that's potentially more digestible. Yeah. So one important thing you can also see is whether a function is actually external or public, which means, like, something that a user can actually call. You know, a smart contract might often have some internal functions that are intended sort of as helper functions, so that can only be run sort of internally within the smart contract. It's part of some process that was set set off by another action. So it's very useful to be able to see exactly which functions are actually available for, you know, the actual users to call or that otherwise can be called by another smart contract. So that's something that you can do with this tool by filtering by functions with a particular type of visibility, for example. Yeah. So, I mean, it's possible, basically, just to, like, filter through using some of the metadata that was collected to try and to actually be able to see what exactly is in each of the types of actions or parameters that were defined for the smart contract. And then one nice little neat feature is that you can basically just draw a network map of which in this case, for example, like, which functions are defined within which which contracts and then what parameters do those each of those functions have. That basically lets you draw, like, a neat little visualization of the overall shape of the the governance service. The one caveat here is that I haven't yet been able to link, contracts to each other, so it doesn't, take into account, like, inheritance information between smart contracts. But here's an example for for just MolokDAO, and you can see how that compares to other contracts when you run it for, for example, you know, seeing that you know, this is a little bit hard to interpret without really knowing what's happening in a particular DAO contract, but this is sort of, like, a quick, very, like, bird's eye view of, like, for example, the complexity or size of the contract is that you can sort of see how many actions are possible to undertake and then how many sort of what the overall complexity of the underlying code is, which is important for, you know, in both, you know, maintenance and legibility of the definition of this organization, and also for kind of understanding how flexible or adaptable the code might be to, you know, any changes that might need to be made as external conditions change. So I think that's kind of the high level overview of what this tool can do right now. I think we're sort of at the half hour mark, which is usually a good time to end the presentation the formal presentation part of these seminars. So I think it makes sense to open it up for questions.

Yeah. Absolutely. That's definitely, like, one of the largest challenges I think that DaaS are facing right now is interfacing with, you know, the existing, government services of, you know, countries and such. So, yeah, no. Definitely. That would be useful for trying to, yeah, clarify the legal status and maybe help define the legal status of of those.

Yes. Yeah. I mean, the idea is, like, literally, the governance surface wasn't a DAO idea. It was an idea that was drawn from, again, this sort of older cybernetics literature, although not expressed in exactly those terms. It relates to things like requisite variety from Ashby, and and you can look at sort of concepts from VSM in Stafford Beer. And what you're basically getting at is a set of structures that relate to the way an organization or or organism is capable of acting. And from a legal context, those things are enshrined in the, let's say, the the bylaws of of a of an organization, how it's able to change them, how its trustees or or board members are selected. So if you really wanted to create a regulatory framework, one of the first ways to do it would be to build some concrete mappings between regular normally accepted governance structures in the legal domain and their equivalent implementations in DAOs. And then insofar as they don't exist, it might be worth implementing them as a point of reference and then demonstrating the similarities and differences at the implementation level. But then, I think, more importantly, representing the similarities that and differences at what I'll call the properties level, where the the properties level relates to things like checks and balances or, like, you know, ways in which certain types of organization level decisions are rendered, legible both to members of those organizations and to, you know, third parties that may, you know, consider it their purview to regulate the behaviors of those organizations.

I just that I'll just make that my comment. I don't wanna eat up the airtime, but I I have a lot to say because I've been trying to develop this concept as Lucia Lucia said, and I'm really excited about the the empirical mapping because I think it makes it a lot more concrete for people coming from a systems engineering background. Sometimes the stuff that I put out there, people are like, WTF, how do you use this? And then when Lucia does great projects like this, I'm like, look. That's the manifestation of the concept that we're describing.

Speaking of, let me drop your sort of foundational favor here in the chat for people to reference.

Yeah. I mean, I think research question wise, definitely one of the sort of one one of the questions that maybe is most tractable also to answer with this kind of tool is about this sort of concept of of size of the governance service. So that's something that I would I would highly recommend you read that paper that I just dropped in the chat there about, basically, this concept of resilience of our organization and and adaptability and how, basically, the size of the control service, governance service of an organization influences an organization's ability to adapt to, like, internal and external changes. So that's something that I think you could use this tool for, and you might also want to use a secondary data source of, for example, the behavior or, you know, ability of a DAO to actually meet its its goals, to try and see if there's any kind of relationship there. So integrating this this data source with something that actually pulls in either on chain data of, like, actually, you know, the behaviors, the actions that have been undertaken through this governance service, I think integrating those neatly is something that I would have loved to have done with a little bit more time. And, you know, I did sort of separately work on a tool to do, but never sort of, like, integrated the two together. So I think that's something that would be really powerful is being able to really sort of define the governance service, but then also see what is what actions are being undertaken through that governance service now that we have that particular lens on, you know, just the raw on chain data. Yeah. Hopefully, that sort of answers your question. And, of course, you know, I'll be available over Slack to to chat with you.

Well, I'm not even sure how to articulate this yet. Just just as background, my my area is in strategic management. That's that's that's my primary area, so I know just enough to get me in trouble. But but as as were giving your presentation, I was definitely thinking about corporate governance and and how this might be used to to map, you know, their strategic space. But but then as Zirgen was commenting, I was thinking about a colleague of mine in Chile. One of the things this company did was write some script to extract information from government policy for lawmakers so that as government policies are updated they're extra you know, and you know how these things are. You can have like a thousand page new legal standing that comes up from regulation and they've got to, sift through it real quickly in order to make sense of it. So I I guess my question is, is there a way then to take, like like, what he's doing with the NLP and it's just extracting language and then use what you've done in order to map out that that governance space? Is is that kind of what you've got here?

Yeah. Yeah. I mean, that sounds awesome. That would be ideal, I think. I don't have a lot of, like, NLP background, so that's why that's not something that I incorporate into this tool, but I think that would be a super useful addition to this tool. So Mhmm. Yeah. And, Riley, I would say that that's definitely another direction.

Do you think then that it there's an opportunity to go to the reverse direction with this? So once we map out the governance space of, say, public policy, to then recommend smart contracts to take our paper into digital formatting for for governance purposes.

I I can imagine maybe using a tool like what you're describing to sort of understand what the like you know? I I I think if I'm understanding you correctly, you're you're sort of trying to understand sort of go backwards and understand what the sort of core components of the Yeah. Well, I I

think I think I'm trying to build on, I think, what Martin asked earlier. Right? So you've got corporations that already exist and have stakeholders, and they've got all this paper policy or maybe it's digitized in some way. So go backwards in analyzing what we have from a historic perspective to to then build the smart contracts after the fact as opposed to going from the smart contract to the analysis and enforcement going from the, paper to the development of the smart contracts.

I see. Yeah. That's definitely something I can I can imagine doing? This tool cannot do that, but I think that would be, you know, that Going that direction. Plausible.

Yeah. I think that would be super valuable. I think one one one thing I kept running into over and over as I, you know, collected lots of data and then tried to make any sense of it, that, sure, it's possible to just, like, pull in anything and everything from, you know, the entire history of a blockchain. But it's really hard to sort of derive meaning from it if you don't know the context of, like, why an action was taken. And that requires, you know, some relatively deep understanding of the actual organization that, you know, through which that action was undertaken. And that often requires, you know, actually talking to people. So I think, yeah, qualitative interviews and other kinds of that kind of sort of qualitative analysis would be really, really helpful, especially in actually understanding, yeah, like, the goals of an organization and members' sort of sense of whether that organization is actually meeting those goals.

Hey. Yeah. This is amazing research, of course. So thanks for sharing it with us. One thing I was curious to to know if you cover in your research is contract up updatability or, like, migration, like, when people move from, like, v one to v two, v three, kind of, like, tracking the differences between those two things. And I was also recently looking at, this this, kind of framework for doing Ethereum coding called MUD. I'll I'll share a link to it. But they have a way of doing, like, automatic contract updating in a development environment and having it be a lot more flexible and dynamic than it than it currently is. So I was just curious, like, how your research intersects with, you know, concepts of updateability and your your observation that, like, the smart contracts aren't the only thing that constitute, you know, a DAO.

Mhmm. Yeah. That's something that could be, you know, either either manually, you could collect sort of, like, you know, the the upgraded contracts as they become upgraded and sort of do a sort of side by side diff comparison, for example, like, see what actually changed at a glance. Or if you actually linked up this kind of tool with some connection to on chain data, you could automatically figure out, you know, starting from some point, what changes have been made to this contract over time. So that's definitely something that I think would be, you know, valuable, especially from the you know, both from a fundamental research perspective of, like, you know, how much our organization's actually having to adapt themselves in this kind of, like, really big way as as well as for, you know, auditing sort of purposes.

Great. Thank you.

Mhmm.

Yeah. So this this overall structure, I think, is most doing this kind of analysis is most feasible when there's, at the very least, some kind of, like, programmatic way to access, like, the API of a tool, for example. So if there is some way to sort of, like, find in a computer, you know, programmatically readable way, like, what exactly a user could do through the tool, that, I think, is is where this kind of analysis would be most easily doable in this kind of, like, semiautomated or, you know, facilitated by code kind of way. But the the same, you know, overall concept definitely applies if trying to understand, of course, you know, just because it's you know, the the user actions that were are undertaken happened through this, like, other GUI and not necessarily can be, like, you know, typed in a command line or otherwise, you know, are so clearly available to the general public as this kind of, like, you know, function that you call. But, yeah, I mean, definitely, the the same kind of overall architecture of, like, trying to understand the governance service would still apply. But, yeah, in terms of of of feasibility, I think it would have to be something where you can, yep, actually access the, like, the API for for the tool.

Yeah. Hopefully, it's pretty straightforward. I tried I tested this this setup shortly before this call to make sure it still works fine. So if you run these instructions, I'll update this ReadMe afterwards, but you can, for example, run this file and specify a URL that you want to download, that you want to to analyze, and it'll do it. It'll create two CSV files for you in your your root directory there with all the objects and parameters and the labels and everything. So, hopefully, pretty straightforward.

you. Great work. Thanks. Good work, Lucia.

Hopefully, you guys can find some useful ones. Thank you.

Bye.