Method and program for generating use cases using ai agents from user interaction objects
An AI agent analyzes web page UI information to generate and store use cases, addressing inefficiencies in existing methods, enabling efficient automation in web environments without source code access.
Patent Information
- Application Number
- KR1020250179060
- Authority / Receiving Office
- KR · KR
- Patent Type
- Patents
- Current Assignee / Owner
- Filing Date
- 2025-11-24
- Publication Date
- 2026-11-06
- Estimated Expiration
- 2045-11-24
AI Technical Summary
Existing methods for extracting use cases from web pages without direct access to source code are inaccurate and inefficient, limiting the application of AI agents in complex and large-scale systems.
An AI agent analyzes web page UI information, such as HTML, DOM, and visual data, to generate use cases using a Large Language Model (LLM), storing them in a knowledge database for reuse and combining them to handle complex requests.
This approach enables accurate and rapid task execution in web environments without source code access, improving automation efficiency and reducing response times by reusing stored use cases.
Smart Images

Figure 112025131396048-PAT00001_ABST
Abstract
Description
Technology Field The present disclosure relates to a method and program for generating use cases from user interaction objects using an AI agent. More specifically, the present disclosure relates to a method and program for generating use cases by analyzing web pages accessed via a website identifier using an LLM. Background Technology In software development, a Use Case (hereinafter "UC") is a unit workflow that defines, from a user-centric perspective, the procedures and scenarios by which a user interacts with a system to achieve specific goals. By clearly describing system functional requirements as the flow of interaction with actors (users, external systems), it serves as a standard for development requirements, design, and testing. While accurately identifying the Use Cases provided by a legacy system is essential during its maintenance and modernization, many legacy systems present difficulties in understanding their actual functions due to a lack of documentation. Considering this reality, the necessity of research on reverse engineering Use Cases from existing source code is deemed very high. Existing use case extraction methods utilize static or dynamic analysis techniques, but they have limitations in that they suffer from reduced accuracy and inconsistent quality in complex, large-scale systems. Furthermore, these conventional technologies primarily focus on reverse engineering to extract use cases and database them for systems where direct access to source code is possible. Recent research on use case generation using AI agent technology also mostly concentrates on source code-based analysis or one-time extraction, making it difficult to efficiently respond to repetitive and diverse user requests. As such, conventional technologies for extracting UC have a fundamental limitation in that they cannot be applied in environments such as general web services or applications where source code is inaccessible. In other words, when dealing with web pages outside the developer's control, existing source code-based reverse engineering techniques cannot be applied. Therefore, in situations where access to source code is unavailable, a technical alternative is required to analyze the UI information (HTML markup, DOM structure, visual information, etc.) of a web page to identify its functions and user workflows, and to automatically derive actionable use cases that can be utilized by an AI agent. Accordingly, the present disclosure enables an AI agent to accurately and rapidly perform tasks with a step-by-step execution plan for complex user requests (e.g., "Please sign up on this website") by generating a use case (technical tree) that includes action procedures based on entry node information and element information derived through the analysis of the hierarchical structure of a webpage. Furthermore, by storing and managing the generated use cases in a knowledge database, when identical or similar user requests are repeated, the stored use cases can be immediately reused without wasting computing resources by creating new use cases, thereby reducing response times and promoting the efficient utilization of system resources. Additionally, there is a need for an integrated solution that can flexibly respond to complex requests by combining multiple use cases, by subdividing and storing use cases into minimum-unit action procedures. Unless otherwise indicated in this specification, the contents described herein are not prior art for the claims of this application, and are not recognized as prior art simply because they may be included herein. The problem to be solved The present disclosure provides a method and program for automatically generating and managing executable use cases by having an AI agent analyze a webpage for which the source code is inaccessible. Specifically, the present disclosure aims to analyze web page UI information (HTML, DOM, visual information) to derive minimum unit use cases that a user can perform, such as sign-up and login, and to organize them into a Tech Tree form necessary for an agent to perform automated tasks. In addition, the present disclosure aims to generate a specific execution plan in the form of a scenario by analyzing the hierarchical structure (tree structure) and web page UI information of a web page, including specific page entry node information for each use case and action procedures such as input and clicks required on that page. Furthermore, the present disclosure aims to establish a systemic foundation that enables an AI agent to quickly and efficiently perform tasks by searching for stored use cases in response to a user's request, by storing generated use cases in a knowledge database. The problems that this disclosure aims to solve are not limited to those mentioned above, and other unmentioned problems will be clearly understood by a person skilled in the art from the description below. means of solving the problem A method for generating a use case performed by an AI agent using a Large Language Model (LLM) according to one embodiment of the present disclosure may include: obtaining a natural language query including a webpage identifier; analyzing a webpage accessed through the webpage identifier using the LLM; and generating one or more use cases based on the analyzed webpage. In one embodiment, the step of analyzing the web page accessed through the web page identifier may include: a step of analyzing the tree hierarchy of the web page to extract path information from the root node to the leaf node of the web page; and a step of analyzing web page UI information for each node web page according to the path information of the web page. In one embodiment, each of the one or more use cases within the webpage may include entry node information regarding a specific webpage within the path information and an action procedure regarding the webpage UI information within the specific webpage of the entry node. In one embodiment, the web page UI information includes information about one or more objects within the web page, and the information about the one or more objects includes information about the name, type, width, height, X coordinate, and Y coordinate of the objects, and the action procedure may include at least one of an action of moving a mouse to the X and Y coordinates of a specific object among the one or more objects, an action of clicking the specific object, and an action having a delay time. In one embodiment, the web page identifier includes at least one of a URL (Uniform Resource Locator), a URI (Uniform Resource Identifier), a web page address, and a hyperlink, and the web page UI information may include at least one of HTML markup, a DOM structure, CSS style information, and visual rendering data. In one embodiment, the step of storing one or more of the generated use cases in a knowledge database may be further included. A computer program stored on a computer-readable recording medium may be provided to execute a method for generating AI agent-based use cases according to one embodiment of the present disclosure on a computer. An information processing device for generating use cases performed by an AI agent using a Large Language Model (LLM) according to one embodiment of the present disclosure comprises: a memory; and at least one processor connected to the memory and configured to execute at least one computer-readable program included in the memory, wherein the at least one program may include instructions for obtaining a natural language query including a web page identifier, analyzing a web page accessed through the web page identifier using the LLM, and generating one or more use cases based on the analyzed web page. Effects of the invention According to one embodiment of the present disclosure, use cases can be automatically derived by analyzing UI information (DOM structure, visual information, etc.) of web pages, even for general web services or applications where direct access to source code is not possible. Through this, the scope of automation application of AI agents can be dramatically expanded to a wide range of web environments where existing source code-based reverse engineering techniques could not be applied. In addition, according to one embodiment of the present disclosure, by generating a use case (technology tree) that includes an action procedure based on entry node information and element information derived through the analysis of the hierarchical structure of a webpage, the AI agent can accurately and quickly perform tasks with a step-by-step execution plan for complex user requests (e.g., "Please sign up on this website"), thereby significantly improving the agent's task execution capability, success rate, and efficiency. Furthermore, according to one embodiment of the present disclosure, by storing and managing generated use cases in a knowledge database, it is possible to immediately reuse stored use cases without wasting computing resources by creating new use cases when identical or similar user requests are repeated, thereby shortening response times and promoting the efficient utilization of system resources. In addition, by subdividing use cases into minimum unit action procedures and storing them, it is possible to flexibly respond to complex requests by combining multiple use cases. The effects of the present disclosure are not limited to those mentioned above, and other unmentioned effects will be clearly understood by those skilled in the art to which the present disclosure belongs from the description in the claims. Brief explanation of the drawing FIG. 1 is a block diagram schematically showing the overall configuration of a use case generation system from an AI agent-based website according to one embodiment of the present disclosure. FIG. 2 is a schematic block diagram showing the hardware configuration of a use case generation system from an AI agent-based website according to one embodiment of the present disclosure. FIG. 3 is a flowchart schematically illustrating a method for generating AI agent-based use cases according to one embodiment of the present disclosure. FIG. 4a is a flowchart illustrating the steps for analyzing a webpage accessed through the webpage identifier of FIG. 3. FIG. 4b is a block diagram schematically illustrating the tree hierarchy of a website according to one embodiment of the present disclosure. FIG. 5 is a drawing showing an example of a website and a webpage UI according to one embodiment of the present disclosure. FIG. 6 is a drawing showing an example of web page UI information according to one embodiment of the present disclosure. FIG. 7 is a drawing showing an example of data extracted from a webpage according to one embodiment of the present disclosure. FIG. 8 is a drawing showing an example of a list of use cases extracted from a webpage according to one embodiment of the present disclosure. FIG. 9 is a block diagram showing an example of a scenario configured by combining use cases according to one embodiment of the present disclosure. Specific details for implementing the invention Hereinafter, specific details for implementing the present disclosure will be described in detail with reference to the attached drawings. However, in the following description, specific descriptions regarding widely known functions or configurations will be omitted if there is a risk that the gist of the present disclosure may be unnecessarily obscured. In the attached drawings, identical or corresponding components are assigned the same reference numerals. Additionally, in the description of the following embodiments, the description of identical or corresponding components may be omitted. However, even if a description of a component is omitted, it is not intended that such component is not included in any embodiment. The advantages and features of the disclosed embodiments and the methods for achieving them will become clear by referring to the embodiments described below in conjunction with the accompanying drawings. However, the present disclosure is not limited to the embodiments disclosed below but may be implemented in various different forms, and the embodiments provided are merely to make the present disclosure complete and to fully inform those skilled in the art of the scope of the invention. The terms used in this specification will be briefly explained, and the disclosed embodiments will be described in detail. The terms used in this specification have been selected to be as generally used as possible, taking into account their functions in this disclosure; however, these terms may vary depending on the intent of those skilled in the art, case law, the emergence of new technologies, etc. Additionally, in specific cases, terms may be arbitrarily selected by the applicant, and in such cases, their meanings will be described in detail in the relevant description of the invention. Therefore, the terms used in this disclosure should be defined not merely by their names, but based on their meanings and the content throughout this disclosure. In this specification, singular expressions include plural expressions unless the context clearly specifies them as singular. Additionally, plural expressions include singular expressions unless the context clearly specifies them as plural. Throughout the specification, when a part is described as including a certain component, this means that, unless specifically stated otherwise, it does not exclude other components but may include additional components. Additionally, the terms "module" or "part" as used in the specification refer to software or hardware components, and the "module" or "part" performs certain roles. However, the meaning of "module" or "part" is not limited to software or hardware. The "module" or "part" may be configured to reside in an addressable storage medium or configured to operate one or more processors. Thus, as an example, the "module" or "part" may include components such as software components, object-oriented software components, class components, and task components, and at least one of processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuits, data, databases, data structures, tables, arrays, or variables. The components and the functions provided within the "module" or "part" may be combined into a smaller number of components and "modules" or "parts," or further separated into additional components and "modules" or "parts." According to one embodiment of the present disclosure, a “module” or “part” may be implemented as a processor and memory. The term “processor” should be broadly interpreted to include a general-purpose processor, a central processing unit (CPU), a microprocessor, a digital signal processor (DSP), a controller, a microcontroller, a state machine, etc. In some contexts, the term “processor” may refer to an application-specific integrated circuit (ASIC), a programmable logic device (PLD), a field programmable gate array (FPGA), etc. The term “processor” may also refer to a combination of processing devices, such as, for example, a combination of a DSP and a microprocessor, a combination of multiple microprocessors, a combination of one or more microprocessors combined with a DSP core, or any other combination of such configurations. Additionally, the term “memory” should be broadly interpreted to include any electronic component capable of storing electronic information. "Memory" may refer to various types of processor-readable media, such as random access memory (RAM), read-only memory (ROM), non-volatile random access memory (NVRAM), programmable read-only memory (PROM), eraseable-programmable read-only memory (EPROM), electrically eraseable PROM (EEPROM), flash memory, magnetic or optical data storage devices, registers, etc. If a processor can read information from memory and / or write information to memory, memory is said to be in an electronic communication state with the processor. Memory integrated in a processor is in an electronic communication state with the processor. In this disclosure, "system" may include, but is not limited to, at least one of a server device and a cloud device. For example, the system may be composed of one or more server devices. As another example, the system may be composed of one or more cloud devices. As yet another example, the system may include a server device and In the present disclosure, a "Large Language Model (LLM)" may refer to a language model capable of inference without fine-tuning and may have more than 10 times as many parameters as a conventional general language model (e.g., more than 100 billion parameters). For example, a Large Language Model may be the Generative Pretrained Transformer (GPT), Gemini, Perplexity, Claude, etc. In the present disclosure, a Large Language Model may include, but is not limited to, a model pre-trained to perform Natural Language Processing (NLP), Text Generation, Semantic Inference, etc. FIG. 1 is a block diagram schematically showing the overall configuration of a use case generation system from an AI agent-based website according to one embodiment of the present disclosure. A system (100) according to one embodiment of the present disclosure can automatically derive and generate use cases desired by a user by utilizing an AI agent for web pages that cannot directly access the source code. Referring to FIG. 1, a system (100) according to one embodiment of the present disclosure may include an overall configuration for generating use cases through interaction between a user (110), an AI agent (130), and a webpage (150). The user (110) is an entity that interacts with the AI agent (130) through natural language queries and inputs a request for a task to be performed on a specific website (e.g., "Sign up on this website," "Analyze the login process," etc.). The user (110) may provide the AI agent (130) with a natural language query that includes a web page identifier (URL, URI, web page address, hyperlink, etc.). The user (110) may include a general user, a system administrator, a developer, or any entity that wishes to perform web automation tasks using another AI agent (130). The AI agent (130) may be an intelligent agent that operates based on a Large Language Model (LM). The AI agent (130) may be operated by at least one processor. The AI agent (130) interprets a natural language query received from a user (110), accesses a webpage (150) through a webpage identifier included in the query, and performs an analysis of the webpage (150). Specifically, the AI agent (130) may perform the following functions. Natural language query processing: Parses and understands a request in the form of natural language entered by the user (110), and can identify the intent and goal of the request from the user (110). Web page analysis: By analyzing the tree hierarchy of the web page (150), path information from the root node to the leaf node can be extracted, and UI information of the web page corresponding to each node (HTML markup, DOM structure, CSS style information, visual rendering data, etc.) can be collected and analyzed. Use Case Generation: Based on analyzed webpage information, one or more use cases can be automatically generated to perform tasks requested by a user. Each use case may include entry node information for a specific webpage and action procedures to be performed on that page (e.g., clicking a specific element, entering text, moving the mouse, etc.). Knowledge Database Management: Generated use cases can be stored in a knowledge database, and by searching for and reusing the stored use cases when identical or similar requests occur later, response times can be reduced and computing resources can be utilized efficiently. The AI agent (130) can be implemented as one or more processors, server devices, cloud computing environments, or a combination thereof, and can integrate various AI technologies such as natural language processing using LLM, web crawling, DOM parsing, and visual information analysis. A webpage (150) represents one or more webpages that the AI agent (130) uses as a target for analysis. A webpage (150) may include multiple pages that constitute a specific website, and each page may be connected in a hierarchical tree structure. For example, starting from a main page corresponding to the root node, subpages such as a sign-up page, a login page, and a product search page may be connected via links. A webpage (150) is a general web service or application that does not have direct access to source code, and the AI agent (130) performs analysis based on UI information of the publicly available webpage. This is a distinguishing feature from conventional source code-based reverse engineering techniques. Looking at the interaction flow between the components in FIG. 1, the user (110) provides a natural language query and a web page identifier to the AI agent (130), and the AI agent (130) can access the web page (150) through the web page identifier to collect necessary information. The AI agent (130) can analyze the collected information to generate use cases and return them to the user (110) or automatically perform the tasks requested by the user. The configuration of the system (100) illustrated in FIG. 1 is exemplary, and additional components (e.g., knowledge database, proxy server, logging system, etc.) may be included depending on the embodiment, and communication between each component may be made through a wired or wireless network. A system (100) according to one embodiment of the present disclosure can expand the scope of application of web automation technology by enabling automated use case generation and execution using AI technology even in a web environment where source code access is impossible. FIG. 2 is a schematic block diagram showing the hardware configuration of a use case generation system from an AI agent-based website according to one embodiment of the present disclosure. The hardware configuration of the electronic device (200) shown in FIG. 2 may correspond to the hardware configuration implementing the AI agent (130) of the system shown in FIG. 1. Referring to FIG. 2, the electronic device (200) may include a communication unit (210), an input unit (220), an output unit (230), a control unit (240), and a memory (250), and may be configured to drive an LLM. The control configuration shown in FIG. 2 is an example for convenience of explanation, and the electronic device (200) may include more or fewer configurations than the configuration shown in FIG. 2. The communication unit (210) may include one or more communication modules that enable communication with other terminals or servers, etc. by connecting the electronic device (200) to a network. For example, the communication module may include a mobile communication module such as 3G, LTE, 5G, etc., a wireless communication module such as Wi-Fi, Bluetooth, etc., and / or various other wired or wireless communication modules. The input unit (220) is configured to acquire information such as user input, video, and audio, and may include various input means such as various mechanical / electronic input means, cameras, and microphones. The output unit (230) is intended to provide information to a user, etc. by generating output related to sight, hearing, or touch, and may include a display, speaker, vibration module, etc. The control unit (240) can control the overall operation of the electronic device (200). The control unit (240) can process signals, data, information, etc. that are input or output through the components described above, or provide certain information or functions according to various applications or algorithms stored in the memory (250). For example, the control unit (240) may correspond to a configuration that substantially performs the steps described below in FIG. 3. Such a control unit (240) may include at least one processor and / or at least one programmable circuit. For example, the control unit (240) may be implemented as hardware such as a CPU, AP (application processor), MCU, GPU, NPU, integrated circuit, ASIC, FPGA, etc. The memory (250) can store programs and data necessary for the operation of the electronic device (200). Additionally, the memory (250) can store data generated or acquired through the control unit (240). The memory (250) may be composed of a storage medium such as ROM, RAM, flash memory, SSD, HDD, or a combination of storage media. FIG. 3 is a flowchart schematically illustrating a method for generating AI agent-based use cases according to one embodiment of the present disclosure. Referring to FIG. 3, a use case generation method (300) according to one embodiment of the present disclosure may be performed by an AI agent using a Large Language Model (LM) and may include a web page identifier reception step (S310), a web page analysis step (S330), and a use case generation step (S350). In step S310, the AI agent may obtain a natural language query from the user that includes a web page identifier. The web page identifier is information for identifying the web page to be analyzed and may include at least one of a URL (Uniform Resource Locator), a URI (Uniform Resource Identifier), a web page address, and a hyperlink. For example, a user can provide a natural language query to an AI agent, such as "Analyze the sign-up process at https: / / example.com" or "Tell me how to purchase products at www.shopping-site.com." These natural language queries include web page identifiers (e.g., URLs), and the AI agent can utilize natural language processing technology to extract web page identifiers from the query and identify the user's intent (request for use case analysis). In one embodiment, a user may transmit a web page identifier to an AI agent in various ways, such as text input, voice input, copy-paste from the clipboard, or sharing the current page via a browser extension. The AI agent may validate the received web page identifier and perform a preliminary check to determine whether the web page is accessible. In addition, the AI agent can analyze received natural language queries to identify the type of task requested by the user (e.g., sign-up, login, product search, payment, information lookup, etc.), which can be utilized to determine priorities or optimize the scope of analysis when generating use cases in subsequent steps. In step S330, the AI agent can use LLM to analyze the accessed webpage through the webpage identifier received in step S310. Step S330 can be differentiated in that it can perform analysis using only the publicly available UI information of the webpage without directly accessing the source code. As described below in Figure 4a, web page analysis can be performed by analyzing the tree hierarchy of the web page and collecting and analyzing UI information regarding the web page. First, as an analysis of the tree hierarchy of a webpage, the AI agent can explore sub-webpages accessible through links, buttons, navigation menus, etc., included in the initial webpage (root node) accessed via the webpage identifier. Through this, it is possible to map the hierarchical structure of the entire website into a tree form and extract navigation path information from the root node to each leaf node. For example, path information such as Main Page (Root Node) → Click Sign Up Button → Sign Up Page (Leaf Node) can be derived. This path information can be utilized to determine the entry node of each use case. The AI agent can collect and analyze detailed UI information for each node (webpage) identified through tree structure analysis. Webpage UI information may include HTML markup, DOM (Document Object Model) structure, CSS style information, visual rendering data, etc. Specifically, the AI agent can extract detailed information about each UI element (button, input field, checkbox, dropdown menu, etc.) within a webpage. This information may include the element's name, type, size (width, height), position on the screen (X-coordinate, Y-coordinate), function (clickability, input availability, etc.), and associated text labels. LLM can understand the meaning and function of each element by analyzing collected UI information. For example, if a text input field labeled "Email," a password input field labeled "Password," and a button displaying the text "Login" are placed adjacently, LLM can recognize this as a UI group that performs the login function. In one embodiment, the AI agent can collect web page information by utilizing web crawling technology, browser automation tools (e.g., Selenium, Puppeteer, etc.), screenshot capture and image analysis technology, and input the collected data into an LLM to perform high-level semantic analysis. In one embodiment, an AI agent may utilize the Browser Runtime Observation Interface (BROI) during the process of collecting and analyzing webpage information. BROI refers to a technical means for collecting and controlling network traffic, DOM structure, script execution status, visual rendering information, session information, etc., in real time using a runtime observation interface provided by a browser or web engine. Specifically, BROI can be implemented through browser automation frameworks such as the Chrome DevTools Protocol, WebDriver API, and Puppeteer / Playwright. Through this, the AI agent can observe dynamic changes in a webpage in real time, capture user interaction events, monitor page loading status, and track JavaScript execution results. Runtime data collected through BROI can provide essential information for understanding the actual behavior of dynamic web applications that cannot be grasped from static HTML source code alone. In addition, the AI agent provides a JavaScript execution environment to analyze web pages implemented with modern web technologies, such as dynamically loaded content, AJAX-based asynchronous communication, and Single Page Application (SPA) structures, and can target the final rendered DOM structure after page loading is complete. In step S350, the AI agent can automatically generate one or more use cases based on the web page information analyzed in step S330. A use case defines a specific task or workflow that a user can perform on a web page in an executable form, and may include a specific execution plan necessary for the AI agent to perform the automated task. Each use case may include the following components: 1) Entry Node Information As information indicating a specific webpage that must be accessed to execute a use case, it may include path information (location in the tree structure) derived in step S330. For example, the entry node of the "Sign Up" use case may be represented by a navigation path such as "Main Page → Top Menu → Click Sign Up Button → Sign Up Page". 2) Action Procedure It defines the step-by-step series of actions that must be performed to complete a use case on the webpage corresponding to the entry node. The action procedure is generated based on webpage UI information and may include the following types of actions: - Mouse Move Action: Move the mouse cursor to the X, Y coordinates of a specific UI element - Click action: Clicking UI elements such as buttons, links, and checkboxes - Text input action: Enter specific text or data into an input field - Selection Action: Select a specific option from a dropdown menu, radio button, etc. - Wait action: Wait for a specific amount of time (delay time) for page loading, receiving asynchronous data, etc. - Validation Action: Determines whether an action succeeds by checking the existence of specific elements, text content, etc. For example, the action procedure for the "Login" use case can be structured as follows: (a) Entering the login page (b) Move mouse to email input field (X=200, Y=300) (c) Click the email input field (d) Enter email address (e.g., "user@example.com") (e) Move mouse to password input field (X=200, Y=350) (f) Click password input field (g) Enter password (h) Move mouse to the login button (X=250, Y=400) (i) Click the login button (j) Wait 2 seconds (Wait for page loading (delay)) (k) Verify successful login (e.g., validate the existence of the username display element) The AI agent can utilize the reasoning capabilities of LLM to identify all possible use cases that a user can perform from the web page structure and UI information analyzed in step S330, and automatically derive the optimal action procedure to complete each use case. In one embodiment, the AI agent may construct a BIM / DSTG (Browser Interaction Model / Dynamic State-Transition Graph) during the use case generation process. BIM / DSTG may refer to a dynamic graph that structures possible user interactions occurring within a webpage into relationships of State, Transition, Condition, and Action based on observation data collected through the aforementioned BROI. Specifically, State may represent the DOM structure and data values of a specific webpage, Transition may represent the process of moving from one state to another, Condition may represent a prerequisite for the transition to occur (e.g., existence of a specific element, validation of an input value), and Action may represent a specific action that triggers the transition (e.g., click, input, waiting). In one embodiment, the AI agent analyzes the constructed BIM / DSTG and converts it into actionable use cases (Tech-Tree), each of which may include an optimal path from a starting state to a target state and a sequence of actions to be performed along that path. Through this BIM / DSTG-based approach, the AI agent can systematically model and automate even complex multi-step workflows. In one embodiment, the generated use case can be structured in the form of a Tech-Tree. A Tech-Tree is a hierarchical decomposition of a complex use case into smaller sub-use cases, where each node represents a minimum unit of executable action, and connections between nodes may indicate the sequence or dependencies between actions. Through this structure, the AI agent can establish a step-by-step and systematic execution plan even for complex user requests. The generated use cases can be expressed in a structured data format (e.g., JSON, XML, etc.), and each action may include attributes such as action type, target element information, input value, and delay time. In one embodiment, the generated use case can be stored in a knowledge database and reused in the future. When the same or similar user request occurs, the AI agent can immediately utilize a use case stored in the knowledge database instead of creating a new use case, thereby drastically reducing response time and efficiently using computing resources (especially resources required for LLM inference). In addition, by subdividing use cases into minimum action procedures and storing them, it is possible to flexibly respond to complex user requests (e.g., "Sign up, log in, and add products to the cart") by combining multiple basic use cases. According to one embodiment of the present disclosure, the generated use case may be returned to a user, directly executed by an AI agent to automatically perform a task requested by the user, or stored in a knowledge database for use. Through this, use cases can be automatically generated using AI technology even in general web environments where source code is inaccessible. Furthermore, by leveraging LLM's powerful natural language understanding and reasoning capabilities, use cases can be derived with high accuracy even for complex and diverse web page structures, which can dramatically expand the scope of application for web automation technology. FIG. 4a is a flowchart illustrating the steps for analyzing a webpage accessed through the webpage identifier of FIG. 3. Referring to FIG. 4a, step S330 of FIG. 3 (the step of analyzing a webpage accessed through a webpage identifier) can be concretized into the following steps S410 and S420. These detailed steps can systematically perform structural analysis and UI information analysis of the webpage to lay the foundation for generating accurate and actionable use cases in subsequent steps. In step S410, the AI agent can analyze the overall hierarchical structure of the website in a tree form, using the webpage accessed through the webpage identifier received in step S310 as the starting point (root node). Websites generally have a structure in which various sub-pages are hierarchically connected through links, buttons, menus, etc., centered around a main page (root node). Starting from the initial webpage corresponding to the root node, an AI agent can identify all navigation elements (links, buttons, menus, hyperlinks, etc.) included in that page and explore the sub-webpages accessible through them. This search process can be performed recursively or iteratively. For example, an AI agent can systematically traverse the tree structure of a website by utilizing Breadth-First Search (BFS) or Depth-First Search (DFS) algorithms. Whenever visiting each node (webpage), the AI agent can record the page's URL, title, and information regarding the element that needs to be clicked to navigate to the page. As a result of the search, the AI agent can extract navigation path information from the root node to each leaf node (the final page that is no longer connected to subpages). Navigation path information represents the sequential sequence of page transitions that must be traversed to reach a specific webpage and can be expressed by the following path example: Path Example 1: Main Page (Root) → Click "Member" link in top menu → Sign-up Page (Leaf) Path Example 2: Main Page (Root) → Click Login Button → Login Page (Leaf) Path Example 3: Main Page (Root) → Click Product Category Menu → Select Electronics Category → Product List Page → Click Specific Product → Product Detail Page (Leaf) This path information can play a key role in determining the entry node for each use case. For example, to execute the "Sign Up" use case, one must first navigate to the sign-up page; by utilizing the path information extracted in step S410, the exact navigation path from the root node to the sign-up page can be identified. In one embodiment, the AI agent stores the tree structure as a graph data structure, and each node may include metadata such as a page URL, page title, parent node information, a list of child nodes, and an access method (information on the element to be clicked). This structured information can be efficiently utilized when generating and executing use cases in subsequent steps. In addition, AI agents can optimize the scope of navigation by applying filtering rules, such as limiting navigation depth, excluding links outside specific domains, or separately marking pages that require login. This enables efficient analysis of tree structures, even for large-scale websites. In step S420, the AI agent can collect and analyze UI information for each node (web page) of the tree structure extracted in step S410. That is, individual UI analysis can be performed on all web pages (or major web pages with high priority) existing in the tree structure. Web page UI information analysis may include the following detailed tasks. 1) HTML Markup and DOM Structure Analysis AI agents can construct a Document Object Model (DOM) tree structure by parsing the HTML source code of each webpage. The DOM structure represents the hierarchical relationships of all HTML elements that constitute a webpage and can include information such as the tag name, attributes, and text content of each element. For example, a login form can have the following DOM structure: <form>element <input type="text" name="email"> Element (email input field) <input type="password" name="password"> Element (password input field) <button type="submit">Element (Login Button) AI agents can analyze this DOM structure to identify the role and function of each element. 2) Collect CSS style information and visual rendering data AI agents can identify the visual attributes (size, position, color, font, etc.) of elements by collecting CSS style information applied to each UI element. Particularly important information is the element's position and size on the screen, which can be expressed by the following attributes. X coordinate (left, x): Horizontal position of the element's top-left corner (in pixels) Y coordinate (top, y): Vertical position of the element's top-left corner (in pixels) Width: The horizontal size of an element (in pixels) Height: The vertical size of an element (in pixels) This location and size information can be used when generating action procedures for a use case in subsequent steps. For example, when defining an action to click a specific button, the X and Y coordinates of that button may be required. In one embodiment, the AI agent can utilize browser automation tools (e.g., Selenium's element.location and element.size properties) to extract the exact location and size of each element. Additionally, it can identify visually recognizable elements by capturing screenshots and applying image analysis techniques. 3) Understanding the function and meaning of UI elements AI agents can leverage LLM's natural language understanding and reasoning capabilities to identify the function and meaning of each UI element. For example, if an input field's name attribute is "email" and its type attribute is "text," the agent can determine that the field is intended for receiving an email address. If a button element's text is "Login," "Login," or "Sign In," the agent can determine that the button is intended for performing a login operation. By analyzing the href attribute and text of a link element, the agent can determine where the link leads. LLM can infer the purpose of each element and the method of user interaction (clickable, inputtable, selectable, etc.) by considering various attributes of UI elements (tag name, attribute value, text content, visual features, etc.). 4) Grouping UI Elements and Identifying Workflows AI agents can identify high-level workflows by grouping semantically related UI elements. For example, if an email input field, a password input field, and a login button are placed adjacently, they can be grouped into a single functional unit called a "login form." This grouping can serve as an important foundation for identifying and defining use cases. As a result of step S420, the following structured UI information can be generated for each node webpage. Webpage: Login Page (URL: https: / / example.com / login) List of UI elements: - Element 1: - Name: email_input - Type: Text input field - Function: Enter email address - X coordinate: 200 - Y coordinate: 300 - Width: 300 - Height: 40 - Element 2: - Name: password_input - Type: Password input field - Function: Password input - X coordinate: 200 - Y coordinate: 360 - Width: 300 - Height: 40 - Element 3: - Name: login_button - Type: Button - Function: Execute login - Text: "Login" - X coordinate: 250 - Y coordinate: 420 - Width: 200 - Height: 50 It can be directly utilized when defining the action procedure for each use case in step S350 (use case creation). This structured UI information is explained in detail in Figure 7 below. After the completion of step S330 (the entirety of FIG. 4a), the AI agent obtains the overall hierarchical structure of the website (tree structure and path information) and detailed UI information of each webpage, which can provide a data basis for generating accurate and actionable use cases in step S350. FIG. 4b is a block diagram schematically illustrating the tree hierarchy of a website according to one embodiment of the present disclosure. Detailed description of Figs. 4a and 4b FIG. 4a is a flowchart illustrating the steps for analyzing a webpage accessed through the webpage identifier of FIG. 3. Referring to FIG. 4a, step S330 of FIG. 3 (the step of analyzing a webpage accessed through a webpage identifier) can be concretized into two main detailed steps. These detailed steps systematically perform structural analysis and UI information analysis of the webpage, thereby laying the foundation for generating accurate and actionable use cases in subsequent steps. Step S410: Analyze the tree hierarchy of the webpage to extract path information from the root node to the leaf nodes. In step S410, the AI agent can analyze the overall hierarchical structure of the website in a tree form, using the webpage accessed through the webpage identifier received in step S310 as the starting point (root node). Websites generally have a structure in which various sub-pages are hierarchically connected through links, buttons, menus, etc., centered around a main page (root node). Starting from the initial webpage corresponding to the root node, an AI agent can identify all navigation elements (links, buttons, menus, hyperlinks, etc.) included in that page and explore the sub-webpages accessible through them. This search process can be performed recursively or iteratively. For example, an AI agent can systematically traverse the tree structure of a website by utilizing Breadth-First Search (BFS) or Depth-First Search (DFS) algorithms. Whenever visiting each node (webpage), the AI agent can record the page's URL, title, and information regarding the element that needs to be clicked to navigate to the page. As a result of the search, the AI agent can extract navigation path information from the root node to each leaf node (the final page that is no longer connected to subpages). The navigation path information represents the sequential series of page transition processes that must be traversed to reach a specific webpage and can be expressed in the following form: Path Example 1: Main Page (Root) → Click "Member" link in top menu → Sign-up Page (Leaf) Path Example 2: Main Page (Root) → Click Login Button → Login Page (Leaf) Path Example 3: Main Page (Root) → Click Product Category Menu → Select Electronics Category → Product List Page → Click Specific Product → Product Detail Page (Leaf) This path information can play a key role in determining the entry node for each use case. For example, to execute the "Sign Up" use case, one must first navigate to the sign-up page; by utilizing the path information extracted in step S410, the exact navigation path from the root node to the sign-up page can be identified. In one embodiment, the AI agent stores the tree structure as a graph data structure, and each node may include metadata such as a page URL, page title, parent node information, a list of child nodes, and an access method (information on the element to be clicked). This structured information can be efficiently utilized when generating and executing use cases in subsequent steps. In addition, AI agents can optimize the scope of navigation by applying filtering rules, such as limiting navigation depth, excluding links outside specific domains, or separately marking pages that require login. This enables efficient analysis of tree structures, even for large-scale websites. Step S420: Analyze webpage UI information for each node webpage based on webpage path information In step S420, the AI agent can collect and analyze detailed UI information for each node (web page) of the tree structure extracted in step S410. That is, it can perform individual UI analysis on all web pages (or major web pages with high priority) existing in the tree structure. Webpage UI information analysis may include the following detailed tasks: 1) HTML Markup and DOM Structure Analysis AI agents can construct a Document Object Model (DOM) tree structure by parsing the HTML source code of each webpage. The DOM structure represents the hierarchical relationships of all HTML elements that constitute a webpage and can include information such as the tag name, attributes, and text content of each element. For example, a login form can have the following DOM structure: element <input type="text" name="email"> Element (email input field) <input type="password" name="password"> Element (password input field) < / button> <button type="submit">Element (Login Button) AI agents can analyze this DOM structure to identify the role and function of each element. 2) Collect CSS style information and visual rendering data AI agents can identify the visual attributes (size, position, color, font, etc.) of elements by collecting CSS style information applied to each UI element. Particularly important information is the element's position and size on the screen, which can be expressed by the following attributes: X coordinate (left, x): Horizontal position of the element's top-left corner (in pixels) Y coordinate (top, y): Vertical position of the element's top-left corner (in pixels) Width: The horizontal size of an element (in pixels) Height: The vertical size of an element (in pixels) This location and size information can play a crucial role when generating action procedures for a use case in subsequent steps. For example, when defining an action to click a specific button, the button's X and Y coordinates may be required. In one embodiment, the AI agent can utilize browser automation tools (e.g., Selenium's element.location and element.size properties) to extract the exact location and size of each element. Additionally, it can identify visually recognizable elements by capturing screenshots and applying image analysis techniques. 3) Understanding the function and meaning of UI elements AI agents can leverage LLM's natural language understanding and reasoning capabilities to grasp the function and meaning of each UI element. For example: If the name attribute of an input field is "email" and the type attribute is "text", the field can be determined to be used for receiving an email address. If the text of a button element is "Login", "Login", "Sign In", etc., the button can be determined to be for performing a login operation. You can determine where the link leads by analyzing the href attribute and text of the link element. LLM can infer the purpose of each element and the method of user interaction (clickable, inputtable, selectable, etc.) by comprehensively considering various attributes of UI elements (tag name, attribute value, text content, visual characteristics, etc.). 4) Grouping UI Elements and Identifying Workflows AI agents can identify high-level workflows by grouping semantically related UI elements. For example, if an email input field, a password input field, and a login button are placed adjacently, they can be grouped into a single functional unit called a "login form." This grouping can serve as an important foundation for identifying and defining use cases. As a result of step S420, the following structured UI information can be generated for each node webpage: Webpage: Login Page (URL: https: / / example.com / login) List of UI elements: - Element 1: - Name: email_input - Type: Text input field - Function: Enter email address - X coordinate: 200 - Y coordinate: 300 - Width: 300 - Height: 40 - Element 2: - Name: password_input - Type: Password input field - Function: Password input - X coordinate: 200 - Y coordinate: 360 - Width: 300 - Height: 40 - Element 3: - Name: login_button - Type: Button - Function: Execute login - Text: "Login" - X coordinate: 250 - Y coordinate: 420 - Width: 200 - Height: 50 This detailed UI information can be directly utilized when defining the action procedures for each use case in step S350 (use case creation). After the completion of step S330 (the entirety of FIG. 4a), the AI agent obtains the overall hierarchical structure of the website (tree structure and path information) and detailed UI information of each webpage, which can provide a complete data base for generating accurate and actionable use cases in step S350. FIG. 4b is a block diagram schematically illustrating the tree hierarchy of a website according to one embodiment of the present disclosure. Referring to FIG. 4b, the tree hierarchy of a website can be represented with the main page (430) as the root node and various sub-pages connected hierarchically. The main page (430) can serve as the entry point of the website and correspond to the top node (root node) of the tree structure. Generally, the main page is the homepage or landing page of the website and may be the page that a user accesses first via a web page identifier (URL). The main page (430) can serve to guide the overall structure of the website and may include navigation elements such as links, buttons, and menus that allow movement to various sub-pages. For example, the main page of an e-commerce website may provide menus that allow movement to product categories, sign-up, login, customer support, etc. Sub-pages directly accessible from the main page (430) may correspond to first-level child nodes of a tree structure. Fig. 4b illustrates a sign-up page (450-1) and a login page (450-2) as representative examples, and the ellipsis (…) may indicate that there may be additional first-level child nodes not shown (e.g., product search page, customer service page, company introduction page, etc.). The sign-up page (450-1) is a page for a user to create a new account on the website and can be accessed by clicking a "Sign Up" button or link on the main page (430). The sign-up page may include a form for receiving information such as name, email, password, and phone number from the user. The login page (450-2) is a page for an existing member to access their account and can be accessed by clicking a "Log In" button or link on the main page (430). The login page may include a form for receiving an email (or ID) and password from the user. The arrows in FIG. 4b represent the connection relationships from the main page (430) to each subpage, which may be a visual representation of part of the path information extracted in step S410. For example, path 1 may represent a direct connection from the main page (430) to the sign-up page (450-1), and path 2 may represent a direct connection from the main page (430) to the login page (450-2). The sign-up page (450-1) may again have sub-pages, which may correspond to second-level child nodes of the tree structure. In FIG. 4b, the real-name verification page (470-1) is illustrated as a child node of the sign-up page (450-1). The real-name verification page (470-1) may be a page that provides an additional step to verify the user's identity as part of the sign-up process. For example, after the user enters basic information on the sign-up page (450-1) and clicks the "Next" button, they may be directed to the real-name verification page (470-1) to perform an identity verification process (e.g., mobile phone verification, credit card verification, etc.). This hierarchical structure can demonstrate that the "Sign Up" use case is not simply completed on a single page, but is a complex workflow that proceeds sequentially across multiple pages. Therefore, the path information for the sign-up use case can be expressed as moving from the main page (430) to the sign-up page (450-1), then moving to the real-name verification page (470-1), and subsequently going through additional steps (e.g., terms agreement page, sign-up completion page, etc.). An ellipsis (…) may indicate that additional steps may exist even after the real-name verification page (470-1). The tree hierarchy shown in FIG. 4b may represent the overall structure of the website that the AI agent analyzes and extracts in step S410. This structural information can be utilized to clearly identify which page to navigate to in order to execute each use case. For example, from the tree structure, it can be determined that the entry node for the "Sign Up" use case is the sign-up page (450-1), the entry node for the "Log In" use case is the login page (450-2), and the entry node for the "Real Name Verification" use case is the real name verification page (470-1). Additionally, the tree structure can be utilized to automatically generate step-by-step navigation paths (scenario paths) to reach specific leaf nodes (final destination pages) from the root node (main page). For example, from the path information, it can be determined that to access the real-name verification page (470-1), one must first move from the main page (430) to the sign-up page (450-1) and then move again to the real-name verification page (470-1). This allows complex workflows spanning multiple pages to be integrated into a single scenario, and the steps that must be taken to access a specific page can be clearly identified. For example, the dependency that basic information must be entered on the sign-up page (450-1) before accessing the real-name verification page (470-1) can be inferred from the tree structure. In one embodiment, the tree structure of FIG. 4b can be stored and managed in various forms, such as a graph database, a JSON tree structure, or an XML hierarchical structure. Each node may include metadata such as a page URL, page title, parent node reference, list of child nodes, and access method (information on the element to be clicked). Additionally, actual websites may have a more complex structure than illustrated in FIG. 4b and may include dozens or hundreds of nodes (pages) and hierarchies of varying depths. The AI agent can be designed to systematically analyze and manage such complex structures as well. The tree hierarchy of Fig. 4b is one of the results of step S330 (web page analysis) and can be directly utilized to define the entry node information and navigation path of each use case in step S350 (use case generation). Through this, the AI agent can accurately and efficiently generate and execute use cases even in complex website structures. FIG. 5 is a drawing showing an example of a website and a webpage UI according to one embodiment of the present disclosure. Referring to FIG. 5, the web page UI of the "Government 24" website is illustrated as a specific example of an actual website (500) that the AI agent of the present disclosure can use as an analysis target. FIG. 5 shows the appearance of an actual web page that is the subject of web page UI information analysis performed in step S330, particularly in step S420, and can make it possible to specifically understand which UI elements the AI agent identifies and analyzes. The webpage illustrated in FIG. 5 may include the main page and login-related pages of the Government 24 service, and multiple UI elements are indicated by numbers. Each number represents an individual UI element that the AI agent must identify and analyze, and these elements may be components of the webpage UI information collected in step S420. The numbers shown in FIG. 5 (e.g., 1, 2, 3, ……, 71, etc.) each refer to a unique UI element, and they may include various types of elements. The top area of a webpage may contain the website's header and navigation elements. For example, the "Government 24" logo element (indicated by number 29), the "Civil Service" dropdown menu (indicated by number 5), and "Login" related elements (indicated by number 34) may be located in this top area. These elements in the header area generally serve as access points to the website's key functions, and the AI agent can analyze them to identify the website's overall structure and available services. Various UI elements providing major services and functions may be arranged in the central area of Fig. 5. In Fig. 5, a login-related UI is prominently displayed in the center and may include elements related to "mobile ID authentication" (indicated as number 52), various input fields, and buttons. In particular, various UI elements related to the login process may be displayed in the form of popups or overlays, which represent UI elements that the user interacts with when performing a login operation. Regarding input fields, multiple text input fields may be displayed in Fig. 5. For example, an input field displaying the text "010" (before number 22) may be a field for receiving the first part of a phone number, and an input field displaying the gray text "12341234" may be a field for receiving the rest of the phone number. Each of these input fields has a unique location (X, Y coordinates) and size (width, height), and the AI agent can collect this attribute information and utilize it when defining the action procedure of a use case in a subsequent step. There may also be multiple button elements. For example, a "PUSH" button (near number 54) and a "QR" button (near number 55) are shown in Fig. 5. Each button is a clickable UI element designed to perform a specific function, and the AI agent can identify the function of the button by analyzing its text label, position, size, style, etc. For example, the "PUSH" button can perform the function of selecting an authentication method via push notifications, and the "Authentication Request" button can perform the function of requesting identity authentication based on entered information. Dropdown menus or selection elements may also be included. The "Civil Service" dropdown menu (No. 5) may be a UI element that allows the user to select one of various civil services. The AI agent can identify the detailed functions provided by the website by analyzing the list of options in these selection elements. There may also be multiple link elements. For example, "ID Login" (No. 71), "QR Code Login" (No. 73), and "Non-member Login (Reservation)" (No. 77) displayed at the bottom of the screen may each be link elements that allow switching to different login methods. These links may provide paths to move from the main page to various subpages in the tree hierarchy described in FIG. 4b. Text and label elements can also be part of important UI information. For example, the text "Login Method" can serve as a label guiding the user to the purpose of the UI section currently being displayed. The text "Government Integrated Login" (near number 10) can indicate that the current login function uses the Government Integrated Authentication System. AI agents can analyze this text information to understand the meaning and context of each UI section and element. Checkboxes or toggle elements may also be included. For example, there may be checkboxes that allow selecting options such as "Auto Login" or "Save ID," and these elements can also be identified by unique numbers. The bottom area may contain footer information for the website. Contact information such as "Call Center 1588-2188, 02-721-0600," address information such as "Government Civil Complaint Guidance Call Center," and copyright information such as "Ministry of the Interior and Safety, All Rights Reserved" may be displayed. As part of the webpage UI, this information can also be subject to analysis by an AI agent. Each number shown in Fig. 5 can be understood as an index or identifier of UI element information collected by the AI agent in step S420. The AI agent can collect and analyze the following information for each element. Element number: Unique identifier (e.g., 1, 2, 3, ……, 71, etc.) Element types: Button, input field, link, dropdown menu, checkbox, text label, etc. Element name / ID: HTML id or name attribute value Text content: Text displayed in the element (e.g., "PUSH", "Login", "Authentication request", etc.) Location information: X coordinate, Y coordinate (in pixels) Size information: Width, Height (in pixels) Status information: Clickable status, input available status, current selection status, etc. Function / Role: Inferred information about the function performed by the element For example, the UI information for the "PUSH" button (near number 51) can be structured as follows: Element number: 51 Element type: Button Element name: push_button Text content: "PUSH" Feature: Select push notification-based authentication method X coordinate: 512 Y coordinate: 145 Width: 50 Height: 20 Clickable: Yes This detailed UI information can be directly utilized when defining the action procedures for each use case in step S350 (use case creation). For example, when creating the "Login via Mobile ID" use case, the AI agent can derive the following action procedures: - Access the main page - Click a login-related button or link - Select "Mobile ID" option (Element number: 7) - Click "PUSH" button (Element number: 51) - Enter "010" in the first part of the phone number input field (element number: near 21) - Enter the remaining number in the phone number rest input field (element number: near 22) - Click the "Request Authentication" button - Waiting for push notification confirmation and approval on mobile device - Login complete confirmation Figure 5 also exemplarily shows that a webpage is composed of a complex hierarchical structure and various UI components. UI elements in the form of popups or overlays are displayed superimposed on the main page, which may be a typical feature of modern web applications. The AI agent can accurately analyze this complex UI structure to determine the visibility, accessibility, and interactability of each element. Additionally, Fig. 5 can demonstrate that various functions and workflows can be provided within a single webpage. For example, within the same login page, various login methods such as "ID login," "QR code login," and "non-member login" are provided, and each method may require different UI elements and action procedures. The AI agent can identify all of these various workflows and generate separate use cases for each. The webpage shown in Fig. 5 may also adopt a responsive design, and the placement and size of UI elements may change dynamically depending on the screen size (e.g., PC environment, mobile environment, etc.). The AI agent can generate use cases that operate stably in various screen sizes and browser environments by taking these dynamic characteristics into account. In one embodiment, when analyzing a webpage such as FIG. 5, the AI agent may use a browser automation tool (e.g., Selenium, Puppeteer, etc.) to access the actual webpage, parse the DOM structure, and automatically extract location and attribute information of each element. Additionally, it may capture screenshots and apply image analysis techniques (e.g., OCR, object recognition, etc.) to identify visually recognizable UI elements. LLM can infer the meaning and function of each element by comprehensively analyzing collected UI information. For example, an element displaying the text "Jeongbu24" along with a logo image can be recognized as a header element representing the website's brand, and a button containing the text "Login" can be inferred to perform the function of initiating the user authentication process. FIG. 5 is an embodiment that specifically shows how the AI agent of the present disclosure can collect and analyze UI information targeting an actual commercial website, and can visually present the actual application result of step S420 (analysis of web page UI information). Through this, it can be made clear that the technology of the present disclosure is not limited to a theoretical concept but can be implemented in an actual web environment. FIG. 6 is a drawing showing an example of web page UI information according to one embodiment of the present disclosure. Referring to FIG. 6, the web page UI information actually extracted by the AI agent from the web page illustrated in FIG. 5 is displayed in the form of structured data (600). FIG. 6 shows the specific result of step S420 (web page UI information analysis), and can visually display the data obtained by the AI agent parsing the DOM structure of the web page and extracting attribute information of each UI element. The data shown in Fig. 6 appears in the form output to the TERMINAL tab of the development environment, which may be the result of an AI agent converting information collected through web crawling or browser automation tools into a text-based structured format. Tabs such as "PROBLEMS 7", "OUTPUT", "DEBUG CONSOLE", "TERMINAL", and "PORTS" are displayed at the top of the screen, and it can be seen that the "TERMINAL" tab is currently active. The extracted UI information may be represented in a hierarchical structure. Each UI element is a number enclosed in square brackets (e.g.,
[1333] It is identified as
[1400] ,
[1401] ,
[1402] ,
[1404] ,
[1405] ,
[1979] , etc., which may correspond to the UI element numbers shown in FIG. 5. After each element number, the type and attribute information of the corresponding element may be listed. Looking at the data structure of Fig. 6, UI element information may be expressed in the following format. listitem\n items can represent elements of the list item type. For example, listitem\n on the first line can represent a webpage's navigation menu or the start of a list structure. Such list structures can reflect the hierarchical organization of information on a webpage.
[1333] button: Citizen Communication Tip-off\n indicates that element number 1333 is of type button and that the text displayed on the button is "Citizen Communication Tip-off". This may be a button element that links to a function on the Government24 website where citizens can report to the government.
[1400] div\n can indicate that element number 1400 is a container element of type div (division). The div element is a general-purpose container used in HTML to group and structure other elements, and it can be the basic unit that constitutes the layout of a webpage. The paragraph item can represent a paragraph-type element, which can refer to a paragraph structure containing text content.
[1404] button: Open Government 24 Guide\n can indicate that element number 1404 is a button type and is a button that displays the text "Open Government 24 Guide".
[1946] StaticText: Government24\n indicates that element number 1946 is of type StaticText and is a static text element displaying the text "Government24". StaticText can mean read-only text that cannot be edited by the user.
[1947] StaticText: Government 24 Guide\n can indicate that element number 1947 is a static text element displaying the text "Government 24 Guide". The emphasis\n item can represent an element of the emphasis type, which is HTML's <em>or <strong>It can be a text emphasis element corresponding to a tag.
[1918] StaticText: Open\n is a static text element with element number 1918 that displays the text "Open" and can be associated with a function to expand specific content or a menu.
[1408] list\n and
[18] listitem\n can represent a list structure and its sub-items. The number
[18] can represent the number of items included in the list, and additional numbers such as
[19] can have similar meanings. StaticText: Call Center\n The item can represent a static text element that displays the text "Call Center".
[1949] StaticText: A trailing space may indicate that the element contains text but is empty or contains only whitespace characters at the time of data extraction.
[1950] StaticText: 02-721-0600 may indicate that element number 1950 is a static text element displaying the phone number "02-721-0600". This may correspond to the call center contact information displayed at the bottom of Fig. 5. 1588-2188,\n (Please check area code '02'.)\n may display other phone number information and related guidance text. [89:00 ~ 18:00 Weekdays]\n may be a text element representing call center operating hours information.
[21] StaticText: Government Civil Complaint Guidance Call Center\n indicates that element number 21 is a static text element displaying the text "Government Civil Complaint Guidance Call Center". StaticText: 110 without area code (toll-free, 24 hours a day, 365 days a year including holidays)\n can be a static text element that displays information about the call center's main number and operating method.
[1455] Items such as div,
[1462] navigation,
[1463] can represent structural elements of a webpage. In particular, navigation can refer to a section containing a website's navigation menu.
[1464] listitem\n,
[1465] It can represent individual items within the navigation menu. link: Privacy Policy\n can represent a link element that leads to the "Privacy Policy" page.
[1466] strong\n is an element of the emphasis (strong) type that can be used to display important text in bold.
[1975] StaticText: Privacy Policy\n may indicate that element number 1975 is a static text element displaying the text "Privacy Policy". This may be a text label associated with the previously mentioned link element.
[22] listitem\n can represent another list item.
[1467] link: Terms of Use\n can represent a link element that leads to the "Terms of Use" page.
[14] listitem\n can represent the 14th item of the list.
[1468] link: Security Center\n can represent a link element that navigates to the "Security Center" page.
[1471] paragraph\n can represent a paragraph type element.
[1979] StaticText: ⓒ Ministry of the Interior and Safety. All Rights Reserved.\n may indicate that element number 1979 is a static text element displaying copyright information. This may correspond to the copyright notice displayed at the bottom of Fig. 5. 'response_format' at the bottom of the screen: <class와 같은 텍스트는 추출된 데이터의 포맷이나 구조를 정의하는 메타데이터 정보일 수 있으며, 이는 ai 에이전트가 수집한 데이터를 특정 형식(예: json, xml 등)으로 구조화하여 저장하고 처리하는 과정을 나타낼 있다.The data format shown in Fig. 6 represents each UI element hierarchically and may include the element type (button, div, list, listitem, link, StaticText, paragraph, navigation, emphasis, strong, etc.) and key attributes (text content, number, etc.). This structured data can be utilized by an AI agent to systematically understand the structure and content of a webpage and to identify the relationships between each element. In one embodiment, the AI agent may store UI information extracted in the form shown in FIG. 6 in a database or file system. The stored data may be converted into various formats such as JSON, XML, CSV, etc., and may be used as input data for LLM in subsequent step S350 (use case generation). In addition, the data in Fig. 6 may contain accessibility information of the webpage. For example, element types such as button, link, and listitem may provide semantic information that can be recognized by assistive technologies such as screen readers. The AI agent can utilize this accessibility information to more accurately identify the role and function of each element. The data shown in Fig. 6 may not directly display the location (X, Y coordinates) and size (width, height) information of each element, but such information can be collected as separate attributes and stored together. For example, additional information such as the following can be stored in the database in association with each element number. For example, additional information can be added in the form of an element as shown below. Element number: 1333 Element type: button Text content: "Public Communication Tip-off" X coordinate: 495 Y coordinate: 78 Width: 120 Height: 30 Clickable: Yes Parent element: 1400 LLM can receive structured UI information as input as shown in Fig. 6, infer the meaning and function of each element, and analyze the relationships between the elements. For example, from the fact that
[1467] link: Terms of Use\n and
[1468] link: Security Center\n appear consecutively and are within the same list structure, LLM can infer that they are a group of related links located in the footer area of the website. In addition, LLM can identify the purpose of each element by analyzing text content. A button with the text "Open Government 24 Guide" can be determined as an interface for receiving guidance, and a link with the text "Privacy Policy" can be inferred to lead to a page providing detailed information about the privacy protection policy. FIG. 6 shows the actual output result of step S420, thereby enabling a specific understanding of what form of data the AI agent of the present disclosure extracts from an actual webpage. This structured UI information is utilized as essential input data for generating use cases in step S350, and can ultimately serve as a basis for generating an actionable procedure that allows the AI agent to automatically interact with the webpage. In one embodiment, data extraction such as that shown in FIG. 6 can be performed by utilizing the Accessibility API of a browser automation tool (e.g., Selenium, Puppeteer). Since the Accessibility API provides semantic information for each element of a webpage, the AI agent can collect not only simple HTML tag information but also role and state information of each element. On the right side of the terminal screen shown in FIG. 6, additional information such as "powers..." and "wsl" may be displayed, which may indicate the execution context of the development environment (e.g., PowerShell, Windows Subsystem for Linux, etc.). This may suggest that the AI agent of the present disclosure can be executed in various operating systems and development environments. FIG. 6 demonstrates that the technology of the present disclosure can be successfully applied to an actual commercial website (Government 24) to extract structured UI information, and may be an important embodiment proving the feasibility and validity of step S420. FIG. 7 is a drawing showing an example of data extracted from a webpage according to one embodiment of the present disclosure. Referring to FIG. 7, web page UI information extracted by an AI agent from the web page illustrated in FIG. 5 is expressed as structured data in the format of JSON (JavaScript Object Notation). FIG. 7 shows the extracted data shown in FIG. 6 in a more detailed and specific form, and the attribute information of each UI element may be systematically organized into key-value pairs. This shows the final output form of step S420 (web page UI information analysis) and may be the result of converting the data collected by the AI agent into a structured format that is easy for the LLM to process. In FIG. 7, two data blocks (710, 720) are shown separated by a dotted line, and each block may contain complete information about a single UI element. The ellipsis (……) at the top and bottom of the screen indicates that although there is actually more UI element data, only a portion is displayed due to space limitations. The first data block (710) may have the following structure: "type": "button" can indicate that the type of the UI element is a button. This can mean that it is an interactive UI element that the user can click. "index": 21 may indicate that the unique identifier or index number of the corresponding element is 21. This index may correspond to the UI element number shown in FIG. 5 and can be used by an AI agent to distinguish and track multiple elements. "text": "Expand Support List" may indicate that the text content displayed on the button is "Expand Support List". This text serves as a label guiding the user on the button's function, and LLM can analyze this text to infer that the button performs the function of expanding the support-related list. "attributes": can indicate the start of an object containing information about the element's additional attributes. HTML attributes can be included within this object. "class": "btn-txt sm ico-arr-bottom toggle" can represent the CSS class property value of the button. This class information can be used to define the button's visual style and behavior. For example, "btn-txt" can mean a text button style, "sm" a small size, "ico-arr-bottom" a downward arrow icon, and "toggle" a toggle (expand / collapse) function. "type": "button" indicates that the HTML type attribute is "button", which specifies that the element performs standard button actions. "related_elements": {} is an object containing information about other elements associated with the element, and it can currently be empty ({}). This may mean that the button does not have a direct relationship with other elements, or that relationship information has not been collected. "selector": "button:nth-child(22)" can represent a CSS selector to select the corresponding element in the DOM tree. This selector refers to an element of type button among the 22nd children of a parent element, and can be used by browser automation tools to programmatically find and interact with such elements. "bounding_box": can indicate the start of an object containing the bounding box information of the element, that is, the position and size information of the area the element occupies on the screen. "x": 1078.703125 can indicate that the X coordinate of the element's top-left corner is 1078.703125 pixels. This can represent the horizontal distance from the left edge of the browser window to the element. "y": 46.25 can indicate that the Y coordinate of the element's top-left corner is 46.25 pixels. This can represent the vertical distance from the top edge of the browser window to the element. "width": 57.9375 can indicate that the width of the element is 57.9375 pixels. This can mean the horizontal size of the button. "height": 22.5 can indicate that the height of the element is 22.5 pixels. This can refer to the vertical size of the button. "xpath": "" is a field containing an XPath expression to select the element, and it can currently be empty (""). XPath is a path language for selecting specific nodes in XML / HTML documents and can be used for purposes similar to CSS selectors. The second data block (720) contains information about other UI elements and may have a similar structure: "type": "button" can indicate that these elements are also of the button type. "index": 29 can indicate that the index number of this element is 29. "text": "Integrated Search" may indicate that the text displayed on these buttons is "Integrated Search". LLM can infer from this text that the corresponding button is intended to execute the integrated search function. Under "attributes": there is "class": "btn-txt ico-before ico-search open-total-search", which represents the CSS class information of the button. From the class name, it can be inferred that this button contains a search icon ("ico-search") and performs the function of opening a full search window ("open-total-search"). "type": "button" can represent the HTML type attribute value. "aria-controls": "layer_totalSearch" is an ARIA (Accessible Rich Internet Applications) attribute that indicates that the ID of the target element controlled by this button is "layer_totalSearch". This information is used for web accessibility and can be utilized by assistive technologies, such as screen readers, to understand the relationship between the button and the content it controls. "related_elements": {} can indicate that the related element information is empty. "selector": "button:nth-child(30)" can be a CSS selector indicating that this button is of type button among the 30th children of the parent element. The sub-information of "bounding_box": includes "x": 910.859375, "y": 73.5, "width": 106.78125, and "height": 40, which represent the X coordinate, Y coordinate, width, and height of this button, respectively. It can be seen that this button has a larger size (width approximately 107 pixels, height 40 pixels) compared to the first button (710). "xpath": "" can indicate that the XPath information is empty. The JSON-formatted data structure shown in Fig. 7 may be suitable for use by the AI agent in step S350 (use case generation). Complete information (type, index, text, attributes, selectors, position, and size) for each UI element is structured, so the LLM can receive this data as input to identify the function of each element and generate an appropriate action procedure. For example, based on the information from the first button (710), the LLM can generate the following action procedure: Action 1: Move the mouse to X=1078.703125, Y=46.25 Action 2: Click the mouse at that location Action 3: Check if "Support List" expands (Verification Action) Based on the information from the second button (720), the following action procedure can be generated: Action 1: Move the mouse to X=910.859375, Y=73.5 Action 2: Click the mouse at that location Action 3: Check if the integrated search layer (layer_totalSearch) is displayed (Verification action) The selector information included in the data of Fig. 7 can provide an alternative method for browser automation tools to locate elements. Instead of coordinate-based clicking, it may also be possible to select and click elements using CSS selectors. For example: javascript / / Selecting and clicking elements using CSS selectors document.querySelector("button:nth-child(22)").click(); Since the aria-controls attribute provides information about the relationships between elements, AI agents can utilize it to predict which UI elements will appear or change after a button click. This can be usefully applied during the validation phase after an action is executed. In one embodiment, structured data such as that shown in FIG. 7 can be stored in the form of an array, and all UI elements of the entire webpage can be listed sequentially. The square brackets [ and ] shown at the top and bottom of FIG. 7 may indicate the beginning and end of the JSON array, and the ellipsis (…) may indicate that additional element information exists within the array but is not shown. The data in Fig. 7 contains precise floating-point coordinate values (e.g., 1078.703125, 910.859375), which demonstrates that modern browsers support sub-pixel rendering and can provide very accurate location information. The AI agent can utilize this precise location information to perform very accurate mouse movements. The data structure shown in Fig. 7 is extensible and may include additional attributes as needed. For example, information such as "visible": true / false (visibility), "enabled": true / false (enabled), "parent_index": N (parent element index), "children_indices": [...] (list of child element indices) may be added. In one embodiment, when the AI agent stores the data of FIG. 7 in a knowledge database, it may store it in association with a webpage URL. This allows for avoiding repetitive analysis of the same webpage and reusing already analyzed UI information. However, considering the possibility that the webpage may be updated, a mechanism may be included to periodically perform re-analysis or verify the validity of the stored data. FIG. 7 illustrates that the AI agent of the present disclosure can extract and store complex web page UI information in a systematic and structured form, and such detailed and accurate data can serve as an essential basis for generating executable and highly reliable use cases in step S350. In particular, it includes all information regarding the exact location (x, y coordinates), size (width, height), selection method (selector), and semantics (text, attribute) of each element, so that the LLM can comprehensively analyze this to derive an optimal action procedure. FIG. 8 is a drawing showing an example of a list of use cases extracted from a webpage according to one embodiment of the present disclosure. Referring to Fig. 8, an example can be shown of a result in which use cases automatically derived by an AI agent based on analysis results are classified by category and a unique identifier (UC01, UC02, etc.) is assigned to each use case to be listed in the form of a technical tree. This list can be stored in a knowledge database as a set of executable commands or unit workflows that the AI agent can use when automating interaction with a webpage. The list of use cases (800) can be broadly classified into three categories based on the functional classification of the website. Examples include user account management, which includes basic user authentication and session management functions of the website; certificate / document issuance, which includes use cases for issuing various official documents; and civil complaint application / processing, which includes complex or special functions where the system processes specific requests from users. First, within the user account management category, UC01 can represent the minimum unit use case of a new user registering in the system, which is 'sign up'. UC02 can represent the use case of a registered user accessing the system and being authenticated, which is 'log in', and UC03 can represent the use case of a user session ending and safely exiting the system, which is 'log out'. Next, within the certificate / document issuance category, UC04 through UC11 may each represent a unique workflow for completing the issuance of a specific certificate. For example, 'UC05: Obtain a Resident Registration Certificate (Abstract)' may include a series of action procedures, such as identifying an entry node to the 'Resident Registration Certificate Issuance' menu on a webpage, entering required information on an application form, and clicking the 'Apply' button. Finally, within the civil complaint application / processing category, UC12 can represent a form in which the basic use case of 'reporting a change of address (+ simultaneous application for various exemptions)' is combined with an extended scenario of 'simultaneous application for various exemptions,' which suggests that a single scenario can be formed by combining minimum unit use cases for complex user requests. UC13 can represent a use case that automates the online application process for passport reissuance, such as 'applying for passport reissuance,' and UC14 can represent a specific service utility use case such as data conversion, such as 'converting an address to English.' The AI agent can utilize a list of use cases (800) to interpret requests, establish execution plans, and reuse use cases. When a user requests, "Please issue a Resident Registration Certificate," the AI agent can map this to the UC05: Receive Resident Registration Certificate (Abstract) use case through natural language processing (NLP), and establish a step-by-step execution plan to perform the task on the actual web page based on the entry node (web page path) and action procedure (coordinate movement, click, input, etc.) information stored in UC05. Since this list (800) itself becomes a core component of the knowledge database, when the same or similar requests are repeated, the stored use cases can be immediately called and used without wasting computing resources to regenerate use cases. This list of use cases can be extracted based on the analysis of UI information (HTML, DOM, visual data) of the web page. FIG. 9 is a block diagram showing an example of a scenario configured by combining use cases according to one embodiment of the present disclosure. Referring to FIG. 9, the process of an AI agent combining the minimum unit use cases derived from the list of use cases (800) of FIG. 8 to construct an agentic workflow, i.e., a scenario, for processing complex and step-by-step user requests can be shown. That is, the AI agent can break down a single natural language query from a user into multiple use case executions and sequentially connect them to automatically perform the task. Scenario (900) can represent an execution path automatically established by the AI agent to perform a complex task, such as 'issue a seal certificate, a land register, and a building register in order after logging in'. The first step of the scenario can be a login step (910). This may correspond to the UC02: Log in use case of FIG. 8. Since most public civil service applications require user authentication, this step can serve as a pre-condition for the execution of subsequent use cases. The AI agent can access the website by executing action procedures stored in this use case (e.g., entering ID / PW, clicking the login button). After successfully logging in, the AI agent can perform the next step, the seal certificate issuance step (930). This may correspond to the UC04: Issuing a seal certificate use case in FIG. 8. The AI agent can follow the action procedure defined in this use case to enter the 'seal certificate issuance' page and automate the process of entering necessary information and applying. After completing the issuance of the seal certificate, the AI agent can perform the task of issuing the land register (950). Although there is no use case with the same name explicitly in the list of use cases in FIG. 8, it can be inferred that this is associated with the UC07: issuing the land (forest) register use case. Finally, the AI agent can perform the building register issuance step (970). This may correspond to the UC08: Obtain a building register use case in FIG. 8. After the land register issuance is complete, the AI agent can execute the action procedure of the corresponding use case to complete the final work. A scenario (900) can represent a data flow and control flow in which each use case is executed sequentially, and can suggest that the success of each step is a condition for starting the next step. By combining use cases in this way to form a complex scenario, the AI agent can provide accurate and automated task execution capabilities for various user requests and significantly expand the scope of website-based business automation (Robotic Process Automation, RPA). As one embodiment, the user interaction object may include a UI object displayed on a website screen. In another embodiment, the user interaction object may include a UI object displayed on a program screen. The method described above may be provided as a computer program stored on a computer-readable recording medium for execution on a computer. The medium may continuously store a computer-executable program, or temporarily store it for execution or download. Additionally, the medium may be various recording or storage means in the form of a single or multiple hardware components, and may not be limited to a medium directly connected to a computer system but may exist distributed over a network. Examples of media may include magnetic media such as hard disks, floppy disks, and magnetic tapes; optical recording media such as CD-ROMs and DVDs; magneto-optical media such as floptical disks; and media configured to store program instructions, including ROM, RAM, and flash memory. Furthermore, other examples of media may include recording or storage media managed by app stores that distribute applications or sites and servers that supply or distribute various other software. The methods, operations, or techniques of the present disclosure may be implemented by various means. For example, these techniques may be implemented in hardware, firmware, software, or a combination thereof. Those skilled in the art will understand that the various exemplary logical blocks, modules, circuits, and algorithmic steps described in connection with the disclosure herein may be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate such interchangeability between hardware and software, various exemplary components, blocks, modules, circuits, and steps have been generally described above in terms of their functional aspects. Whether such functions are implemented in hardware or in software depends on the design requirements imposed on the specific application and the overall system. Those skilled in the art may implement the functions described in various ways for each specific application, but such implementations should not be construed as departing from the scope of the present disclosure. In a hardware implementation, the processing units used to perform the techniques may be implemented in one or more ASICs, DSPs, GPUs, digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), processors, controllers, microcontrollers, microprocessors, electronic devices, other electronic units designed to perform the functions described in this disclosure, computers, or a combination thereof. Accordingly, the various exemplary logic blocks, modules, and circuits described in connection with the present disclosure may be implemented or performed by any combination of general-purpose processors, DSPs, ASICs, FPGAs or other programmable logic devices, discrete gate or transistor logic, discrete hardware components, or those designed to perform the functions described herein. A general-purpose processor may be a microprocessor, but alternatively, the processor may be any conventional processor, controller, microcontroller, or state machine. The processor may also be implemented as a combination of computing devices, for example, a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors coupled with a DSP core, or any other combination of configurations. In firmware and / or software implementations, techniques may be implemented as instructions stored on a computer-readable medium such as random access memory (RAM), read-only memory (ROM), non-volatile random access memory (NVRAM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable PROM (EEPROM), flash memory, compact disc (CD), magnetic or optical data storage devices, etc. The instructions may be executable by one or more processors, and may cause the processor(s) to perform specific aspects of the functions described in this disclosure. Storage media may be any available media accessible by a computer. As a non-limiting example, such computer-readable media may include RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other media accessible by a computer that can be used to transfer or store desired program code in the form of instructions or data structures. Additionally, any connection is appropriately made to a computer-readable medium. The software module may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, a hard disk, a removable disk, a CD-ROM, or any other known form of storage medium. An exemplary storage medium may be connected to a processor so that the processor can read information from the storage medium or write information to the storage medium. Alternatively, the storage medium may be integrated into the processor. The processor and the storage medium may exist within an ASIC. The ASIC may exist within a user terminal. Alternatively, the processor and the storage medium may exist as separate components within the user terminal. Although the embodiments described above have been described as utilizing aspects of the subject matter disclosed herein in one or more standalone computer systems, the present disclosure is not limited thereto and may be implemented in conjunction with any computing environment, such as a network or a distributed computing environment. Furthermore, aspects of the subject matter in the present disclosure may be implemented in a plurality of processing chips or devices, and storage may be similarly affected across a plurality of devices. Such devices may include PCs, network servers, and portable devices. Although the present disclosure has been described in relation to one embodiment, various modifications and changes may be made without departing from the scope of the present disclosure as understood by a person skilled in the art to which the invention of the present disclosure pertains. Furthermore, such modifications and changes should be considered to fall within the scope of the claims appended to this specification. < / strong> < / em> < / button> < / form>
Claims
Claim 1 A method for generating use cases performed by an AI agent using a Large Language Model (LLM), comprising: a step of obtaining a natural language query including a webpage identifier; a step of analyzing a webpage accessed through the webpage identifier using the LLM; a step of generating one or more use cases based on the analyzed webpage; a step of storing the generated one or more use cases in a knowledge database; a step of, when a new natural language query is obtained, searching for a previously stored use case corresponding to the new natural language query in the knowledge database, and if the searched use case exists, reusing the searched use case without regenerating the use case using the LLM; a step of, when the natural language query is a complex request requiring multiple tasks, breaking down the complex request into multiple unit tasks; and a step of configuring an agentic workflow that searches for use cases corresponding to each of the multiple unit tasks from the knowledge database and sequentially connects them. Claim 2 A method for generating AI agent-based use cases according to claim 1, wherein the step of analyzing the web page accessed through the web page identifier comprises: a step of analyzing the tree hierarchy of the web page to extract path information from the root node to the leaf node of the web page; and a step of analyzing web page UI information for each node web page according to the path information of the web page. Claim 3 In paragraph 2, each of the one or more use cases within the webpage comprises an entry node information regarding a specific webpage within the path information and an action procedure regarding the webpage UI information of the entry node within the specific webpage. Claim 4 In paragraph 3, the web page UI information includes information about one or more objects within the web page, the information about the one or more objects includes information about the name, type, width, height, X coordinate, and Y coordinate of the objects, and the action procedure includes at least one of an action of moving a mouse to the X and Y coordinates of a specific object among the one or more objects, an action of clicking the specific object, and an action having a delay time, a method for generating an AI agent-based use case. Claim 5 A method for generating AI agent-based use cases according to claim 4, wherein the web page identifier includes at least one of a URL (Uniform Resource Locator), a URI (Uniform Resource Identifier), a web page address, and a hyperlink, and the web page UI information includes at least one of HTML markup, a DOM structure, CSS style information, and visual rendering data. Claim 6 delete Claim 7 A computer program stored on a computer-readable recording medium for executing a method for generating AI agent-based use cases according to any one of paragraphs 1 to 5 on a computer. Claim 8 As an information processing device for generating use cases performed by an AI agent using an LLM (Large Language Model), memory; An information processing device comprising at least one processor connected to the memory and configured to execute at least one computer-readable program included in the memory, wherein the at least one program comprises instructions for configuring an agentic workflow that, when a new natural language query is obtained, searches for a previously stored use case corresponding to the new natural language query in the knowledge database, and if the searched use case exists, reuses the searched use case without regenerating the use case using the LLM, and when the natural language query is a complex request requiring multiple tasks, breaks down the complex request into multiple unit tasks, and searches for use cases corresponding to each of the multiple unit tasks from the knowledge database and sequentially connects them.
Citation Information
Patent Citations
Chatbot-based web page navigation apparatus and method
KR1020200119016A
Apparatus and method for providing LLM-based browser helper
KR1020250132137A
