An agent capability management and control method, device, equipment and medium

Abstract

This application relates to the field of artificial intelligence technology, and provides a method, apparatus, device, and medium for intelligent agent capability management, including: responding to a capability invocation request initiated by an intelligent agent based on an entry skill, obtaining the set of visible capabilities of the current user through a local agent process; based on the set of visible capabilities, obtaining a target business capability unit from a locally hosted area through the local agent process, wherein the local hosted area is located outside the intelligent agent's skill search path; establishing the runtime context of the target business capability unit through the local agent process, and returning context content or execution results related to this invocation to the intelligent agent. This application achieves unified management and control across intelligent agents, intellectual property protection, and fine-grained invocation control.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, specifically to a method, device, equipment, and medium for managing the capabilities of an intelligent agent. Background Technology

[0002] Currently, with the evolution of large language model applications, intelligent agent platforms generally support extending capabilities through skill mechanisms. Skills are typically represented as a set of description files located in the local file system, which are automatically discovered, loaded, and invoked on demand by the intelligent agent at runtime. In existing technologies, manufacturers usually package and distribute the complete skill catalog to users, who then place it in the intelligent agent's skill search root directory. When the intelligent agent starts up or uses the skill, it directly reads the skill description files. All business semantics are exposed to the intelligent agent in plaintext, and the business logic can run long-term after a one-time installation on the user's local machine.

[0003] However, this method of directly distributing local skills has the following problems: Once a skill is installed, it is completely out of the manufacturer's control. The manufacturer cannot limit the frequency of use, control quotas, force version upgrades, downgrade capabilities, or temporarily remove the skill when it is used, which hinders the implementation of commercial and regulatory requirements such as paid subscriptions, pay-as-you-go billing, and financial compliance; The skill's description file and its associated resources are presented to the agent and user in plain text, resulting in the direct exposure of intellectual property rights such as core prompts, business rules, and industry knowledge, which are easily copied, reverse-engineered, or redistributed; After the same user installs the skill in multiple agents, each agent independently holds a copy of the skill, making it difficult for the manufacturer to form a consistent view of measurement, authentication, and permissions among agents, which can easily lead to cross-agent abuse or quota miscalculations; The skill market and plugin market are usually controlled by the agent platform, and the manufacturer's updates, gray-scale releases, and removals are affected by platform rules and review, making it impossible to have complete autonomy; Once a local skill or plugin is installed, its capabilities exposed to the agent are... The set of functions is relatively fixed, making it difficult to switch visibility capabilities at runtime based on dynamic factors such as user identity, time, risk control status, and compliance gray-scale. Financial scenarios have mandatory requirements for pre-call manual confirmation, sensitive parameter masking, and audit backtracking. Existing local skills lack a unified runtime interception point, which can only be implemented by the agent or front-end application, resulting in poor consistency and difficulty in closing the audit loop. Existing skill calls are usually at the granularity of the entire skill package, and cannot dynamically decide to inject only necessary fragments based on the current task focus, context length, semantic dependencies, and risk level, which can easily lead to context waste and interference from irrelevant information. Existing solutions usually only control what is seen, and cannot constrain the commands that the agent will subsequently issue, whether the parameters are unauthorized, or whether the actions are legal at the state machine level. They lack execution-side closed-loop protection when facing model illusions. Many solutions only perform one-time approval or rejection, and cannot combine the continuous success rate of the task, the remaining context, version stability, risk level, and other states to perform elastic quotas, gray-scale switching, circuit breaking, and recovery. Therefore, there is an urgent need for an agent capability management solution that can achieve runtime control, cross-agent consistency control, intellectual property protection, dynamic capability adjustment, financial compliance support, efficient use of context, execution-side closed-loop protection, and task continuity regulation. Summary of the Invention

[0004] To address the problems of existing technologies, such as skill distribution being detached from manufacturer control, exposure of intellectual property rights, fragmented cross-agent management, static and fixed capabilities, insufficient compliance support, coarse-grained use of context, insufficient execution-side constraints, and incomplete task-state feedback, this application provides an agent capability management method, device, equipment, and medium to establish an intermediate control layer between the agent and business capabilities. This migrates the capability control point from the time of distribution to the runtime, thereby achieving unified management and control across agents, intellectual property protection, and refined invocation control.

[0005] To achieve the above objectives, this application provides a method for managing the capabilities of an intelligent agent, comprising: responding to a capability invocation request initiated by an intelligent agent based on an entry skill, obtaining the set of visible capabilities of the current user through a local proxy process; based on the set of visible capabilities, obtaining a target business capability unit from a local hosting area through the local proxy process, wherein the local hosting area is located outside the skill search path of the intelligent agent; establishing the running context of the target business capability unit through the local proxy process, and returning context content or execution result related to this invocation to the intelligent agent.

[0006] The above solution eliminates the fragmented management and security risks caused by multiple agent skill copies, improves the response speed of management and control such as gray-scale switching and emergency shutdown, and avoids the inconsistency of standards caused by repeated implementation on each terminal. The streamlined call path effectively filters context interference, improves the model response hit rate, and suppresses unauthorized and abnormal operations caused by illusions from the source, making risk convergence more accurate and in line with the actual business.

[0007] In some embodiments, the agent capability management method further includes: maintaining a shared session state and authentication state across agents through the local agent process, wherein the session state includes the context of the currently entered business capability unit, the local agent process runs as a command line process or a resident service process, and state sharing across agents is achieved through a local state file, wherein the local state file uses file locking or atomic write mechanisms to ensure consistency of concurrent access; maintaining a metering state through the local agent process, wherein the metering state includes a triplet quota for user, business capability unit and version, and performing triplet quota verification for each call.

[0008] The above solution avoids the fragmented management caused by each agent independently holding a copy of the skills in the traditional multi-agent environment. The session state is persisted to the local configuration file by the agent process and shared across agents, giving the manufacturer fine-grained management capabilities on a session-by-session basis.

[0009] In some embodiments, establishing the runtime context of the target business capability unit through the local agent process includes: selecting necessary fragments from the target business capability unit and assembling them as context-enhanced content based on task focus, context constraints, and business capability unit metadata.

[0010] The above approach makes the injected content more compatible with the current task, reduces interference from irrelevant information, and reduces the performance loss caused by long contexts.

[0011] In some embodiments, returning context content or execution results related to the current call to the agent includes: returning the context enhancement content to the agent through a standard output channel, and outputting the context enhancement content separately from the prompting information.

[0012] The above solution achieves the separation of the output channel, improving the detectability and security of the technical implementation.

[0013] In some embodiments, the agent capability management method further includes: receiving a controlled business action initiated by the agent through the local agent process; verifying whether the controlled business action belongs to the legal action set of the current business capability unit based on a state machine; and in response to the controlled business action not belonging to the legal action set, generating guidance prompt information based on the current legal action set and the type of unauthorized action through a preset correction template to guide the agent back to the legal state.

[0014] The above scheme forms a closed-loop protection on the execution side, reducing unauthorized commands, dangerous parameters, or abnormal actions caused by model illusion.

[0015] In some embodiments, the intelligent agent capability management method further includes: in response to the target business capability unit involving a sensitive operation, triggering a manual confirmation process through the local agent process; recording the confirmation process and call events to the audit log, and asynchronously reporting the audit log to the remote management service.

[0016] The above solution uses the proxy process as the call path. Since the controlled business actions are initiated through the local proxy process, the proxy process can perform unified verification on this path, providing a unified compliance interception point and ensuring the consistency of risk control.

[0017] In some embodiments, the agent capability management method further includes: evaluating the task state through the local agent process and constructing a runtime decision state vector based on the task state; and dynamically adjusting the execution strategy through the local agent process based on the runtime decision state vector, wherein the execution strategy includes at least one of gray-scale version switching, quota elastic adjustment, and capability degradation.

[0018] The above scheme uses task-state feedback and adaptive control to make gray-scale switching and risk convergence closer to the real task state, rather than relying solely on static rules.

[0019] Furthermore, this application also provides an intelligent agent capability management device, comprising: an entry skill module, used to respond to a capability call request initiated by an intelligent agent based on an entry skill, and obtain the set of visible capabilities of the current user through a local agent process; a local agent process module, used to obtain a target business capability unit from a local hosting area through the local agent process based on the set of visible capabilities, wherein the local hosting area is located outside the skill search path of the intelligent agent; and a business capability hosting module, used to establish the running context of the target business capability unit through the local agent process, and return the context content or execution result related to this call to the intelligent agent.

[0020] The above solution achieves runtime management of intelligent agent capabilities, cross-intelligent agent consistency management, intellectual property protection, dynamic capability adjustment, financial compliance support, efficient use of context, execution-side closed-loop protection, and task continuity control through the collaborative work of the entry skill module, local agent process module, and business capability hosting module.

[0021] Furthermore, this application also provides a computer device, the computer device comprising: a memory and at least one processor, the memory storing instructions; the at least one processor invokes the instructions in the memory to cause the computer device to execute the intelligent agent capability management method as described above.

[0022] The beneficial effects of this computer device are similar to those of the aforementioned intelligent agent capability management device, and will not be repeated here.

[0023] In addition, this application also provides a computer-readable storage medium storing instructions that, when executed by a processor, implement the intelligent agent capability management method as described above.

[0024] The beneficial effects of this storage medium are similar to those of the aforementioned intelligent agent capability management device, and will not be repeated here.

[0025] The beneficial effects of this application are as follows: Unlike existing technologies, this application discloses a method, apparatus, device, and medium for intelligent agent capability management. By decoupling entry skills from business capabilities, it uses the local agent process as a unified control anchor point and replaces static skill descriptions with runtime context injection. This migrates the skill usage control point from distribution to runtime, allowing manufacturers to continue applying runtime controls such as frequency, version, permissions, and compliance after the skill is installed. This effectively improves the feasibility of implementing paid, pay-as-you-go, and financial compliance scenarios. Leveraging the exclusivity of the local agent process, the same user's skill usage in a multi-agent environment has a consistent view of measurement, authentication, and auditing, avoiding the fragmented management caused by traditional multi-agent systems each holding a copy of the skill. Business skills are invisible to the intelligent agent, hosted locally in a packaged or encrypted form, and only temporarily injected into the intelligent agent context during invocation, reducing the possibility of core prompts, business rules, and industry knowledge being copied or reversed. The entry point on the intelligent agent side is stable as a guiding skill, while the list of effective capabilities can be updated based on identity and time. Dynamic changes in intervals, gray-scale deployments, risk control, task success rates, and context reserves effectively improve the response speed of control actions such as gray-scale releases, emergency shutdowns, and scenario-based activations. The proxy process serves as the invocation path; since controlled business actions are initiated through the local proxy process, unified verification can be performed on this path, centrally implementing financial compliance requirements and avoiding inconsistencies across different endpoints. Through a task-focus-driven fragment-level injection mechanism, the proxy process only transmits skill fragments relevant to the current task, reducing context redundancy and irrelevant information interference, thereby improving model response efficiency and task hit rate. By performing state machine verification, unauthorized access rejection, correction prompts, and continuous unauthorized access circuit breakers on controlled business actions initiated through the local proxy process entry point, a closed-loop protection is formed on the execution side within the business capability path provided by the manufacturer, reducing the risk of unauthorized operations caused by model illusions. The proxy process can combine task success rates, version stability, and remaining context to flexibly adjust skill versions and quotas, making gray-scale switching and risk convergence closer to the real task state, rather than relying solely on static rules. Attached Figure Description

[0026] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort, wherein: Figure 1 This is a flowchart illustrating the intelligent agent capability control method provided in this application; Figure 2 This is a schematic diagram of the intelligent agent capability control device provided in this application; Figure 3 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Detailed Implementation

[0027] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of the embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of this application.

[0028] The terms "first," "second," and "third" used in the embodiments of this application are for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first," "second," or "third" may explicitly or implicitly include at least one of that feature. In the description of this application, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or devices.

[0029] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a mutually exclusive, independent, or alternative embodiment. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0030] This application provides a method for managing the capabilities of intelligent agents. This method constructs a three-layer architecture consisting of entry skills, local agent processes, and local hosting areas, and moves the capability control point from the distribution time to the runtime, thereby achieving fine-grained management and control of the capabilities of intelligent agents.

[0031] like Figure 1 As shown, the method includes the following steps: Step S100: In response to the capability call request initiated by the intelligent agent based on the entry skill, the visible capability set of the current user is obtained through the local agent process. The visible business capability set can be jointly determined by the remote authorization result, the local visibility range configuration, the gray-scale strategy or the risk control strategy.

[0032] The entry skill does not include the complete business process, private prompt word template, internal business rules and business resource files of the target business capability unit, but at least includes the calling convention, capability selection principle or public usage guidelines for the local proxy process.

[0033] Specifically, entry-level skills differ fundamentally from existing skill packages that contain complete business logic descriptions, prompt templates, and script resources. In existing technologies, agent platforms typically require skills to include skill description files and related business resource files. The agent automatically discovers and loads these skill packages by scanning specific directories during startup or runtime, making the business semantics completely transparent to the agent. This mechanism leads to the manufacturer losing control once the skill package is distributed, and core intellectual property is easily leaked.

[0034] It should be emphasized that the entry skill in this embodiment does not include the complete business process of the target business capability unit, private prompt word templates, internal business rules, and auxiliary resource files. Its content is limited to the routing conventions for calling the local proxy process, capability selection principles, and public usage guidelines, thereby decoupling the entry route from the business entity and avoiding the exposure of core business logic and intellectual property rights at the entry layer.

[0035] The entry point skill acts as a stable entry point or router. The capability entry point perceived by the agent is always this single entry point skill, while the actual set of available business capabilities is dynamically determined by the local agent process at runtime, thus decoupling the entry point from the business capabilities. When the agent initiates a capability call request based on this entry point skill according to user intent or task requirements, the request does not directly request the loading of a specific business skill package, but rather requests the invocation of the local agent process. As the core control hub of this embodiment, the local agent process, upon receiving the call request, first obtains the set of visible capabilities for the current user. This set of visible capabilities can be retrieved in real time from a remote management service, or it can be updated based on local caching combined with remote policies. Its content indicates the list of business capability units authorized for use by the current user at the current moment and in the current environment.

[0036] This step enables dynamic control of capability visibility, allowing manufacturers to adjust a user's available capability set in real time based on their subscription status, risk control requirements, compliance strategies, etc., without requiring the user to reinstall or update their skill pack.

[0037] In this optional embodiment, the entry skill specifically includes routing information, which instructs the agent to invoke the corresponding sub-command of the local agent process when it needs to perform a target type task, and the entry skill does not contain a complete business logic unit or private resources.

[0038] The above process decouples the entry point from business capabilities. This design makes the structure of the entry point skill extremely streamlined, without including the complete business process of the target business capability unit, private prompt word templates, internal business rules, and business resource files. It only carries the calling conventions for the local proxy process, capability selection principles, and public usage guidelines, thereby avoiding the exposure of core business logic at the entry point layer.

[0039] The local hosting area is the physical storage space used in this embodiment to store business capability units. Its key feature is that it is located outside the agent's skill search path, and its directory structure does not conform to the agent's skill discovery specifications. In existing technologies, skill packages are typically placed in a preset skill search root directory of the agent, which the agent discovers by traversing this directory. However, this embodiment stores business capability units in a directory that the agent cannot find through its automatic discovery mechanism, thus achieving physical existence of the business capability units but semantic invisibility to the agent.

[0040] Specifically, the target business capability units are stored in the local hosting area as packaged products. The packaged products are downloaded from the remote management service by the local agent process, their integrity is verified, and then they are decompressed.

[0041] The target business capability unit is stored outside the agent's skill search path and is not registered as a skill directory that the agent can automatically discover. In some embodiments, it can also be made not to meet the automatic discovery specifications of a specific agent platform by adjusting the directory structure, removing the discovery list of a specific platform, or encrypting or encoding the storage.

[0042] Furthermore, the agent can only perceive entry skills, which contain only routing information and not complete business logic units or private resources. When the agent needs to execute a certain type of task, it invokes the corresponding sub-command of the local agent process based on the routing information in the entry skill. After receiving the invocation request, the local agent process retrieves the target business capability unit from the locally hosted area, which is located outside the agent's skill search path and whose directory structure does not conform to the agent's skill discovery specifications.

[0043] The local agent process performs runtime processing on the target business capability unit and injects the processing results into the agent's context. This process decouples the entry-level skills from the business capabilities, making the business capabilities completely invisible to the agent's skill discovery mechanism.

[0044] By decoupling entry skills from business capabilities, the technology achieves both intellectual property protection and platform independence. Entry skills only carry routing conventions for calling local agent processes and do not contain complete business logic units or private resources. Business capabilities are completely invisible to the agent's skill discovery mechanism. This structure ensures that the agent's perception of the capability list is stable as a guiding skill, while the effective set of business capabilities dynamically changes with remote decisions made at runtime.

[0045] Step S200: Based on the set of visible capabilities, the target business capability unit is obtained from the local hosting area through the local agent process, wherein the local hosting area is located outside the skill search path of the agent.

[0046] Specifically, the target business capability unit is stored in a local hosting area, which is outside the agent's skill search path and the directory structure does not conform to the agent's skill discovery specifications. Business capability units are entities that actually carry business logic, prompt word templates, scripts, and other resources, and are stored in the local hosting area as packaged artifacts.

[0047] Once the local agent process determines the target business capability unit that the user needs based on the set of visible capabilities, it will retrieve that unit from the local hosting region. The retrieval method may include: if a valid cache of the unit already exists in the local hosting region, it will read it directly; if it does not exist or the version is expired, it will download it from the remote management service, verify its integrity, and then decompress it to the local hosting region.

[0048] Because the locally hosted region is not within the agent's search path, the agent cannot enumerate, load, or execute these business capability units on its own. All access to business capability units must go through the controlled channel of the local agent process. This design not only protects the intellectual property within the business capability units but also provides an interception point for subsequent runtime management.

[0049] Step S300: Establish the runtime context of the target business capability unit through the local agent process, and return the context content or execution result related to this call to the agent.

[0050] In the basic embodiment, the local agent process establishes an initial task context by entering the local managed directory of the target business capability unit and reading its documentation. In the enhanced embodiment, the local agent process can further dynamically select necessary capability fragments for assembly based on the current task focus, context constraints, and metadata of the target business capability unit, and return the generated context enhancement content to the agent in a structured form.

[0051] The core idea of ​​runtime processing is on-demand injection and minimal exposure. That is, only the minimum amount of information required for the current task is injected into the agent's context, rather than exposing the entire business capability unit. After processing, the local agent process injects the processing result into the agent's context. Injection can be done by returning the result to the agent through the standard output channel or through other inter-process communication mechanisms. The injected content serves as context enhancement for the agent's current dialogue or task, guiding the agent to execute the corresponding business logic.

[0052] Through this step, this embodiment achieves controlled use of business capabilities. The manufacturer can dynamically adjust the content, timing, and method of injection during runtime, thereby meeting the needs of complex scenarios such as paid systems, pay-as-you-go billing, and financial compliance.

[0053] This embodiment constructs a closed-loop system for agent capability management through the collaborative work of entry skills, local agent processes, and local hosting areas. The entry skill serves as a stable entry point, decoupling the agent from specific business capabilities. The local agent process acts as the control center, undertaking core management functions such as authentication, whitelist acquisition, capability acquisition, and runtime processing. The local hosting area, as physical storage, achieves semantic invisibility of business capabilities. This system migrates capability control points from the traditional distribution phase to the runtime phase, enabling manufacturers to continue applying effective control after skills are installed, improving technical effects such as intellectual property protection, cross-agent consistency management, and dynamic capability adjustment.

[0054] In this optional embodiment, the local agent process performs runtime processing on the target service capability unit, including: selecting necessary capability fragments from the target service capability unit based on the current task focus and context constraints; and assembling the capability fragments into context-enhanced content.

[0055] In this context, the task focus refers to the type, stage, or objective of the task that the agent intends to perform. The key to this embodiment is that the construction of the task focus does not rely on intrusive perception of the agent's internal state, but rather is inferred from explicit or semi-explicit information available to the local agent process.

[0056] Specifically, task focus can be constructed through a combination of one or more pieces of information, such as the command name passed to the local agent process when the agent invokes it. In this way, the local agent process can accurately capture task focus without intruding on the agent's internal logic, thus providing a basis for subsequent segment selection.

[0057] Context constraints refer to limitations on the length, format, and type of injected content. The most typical example is the remaining token budget. Agents or their host environments typically limit the number of tokens injected in a single context injection to avoid exceeding the model's processing capacity or wasting resources. After acquiring the current task focus, the local agent process, based on the remaining token budget, selects necessary capability fragments from the target business capability units. For example, if the remaining token budget is small, it prioritizes core prompt word fragments most directly related to the current task focus, omitting auxiliary fragments such as background knowledge and examples. If the remaining token budget is sufficient, a more complete set of fragments can be selected.

[0058] In addition, context constraints can also include risk level constraints. For example, for high-risk tasks, segments containing more security tips and compliance constraints can be selected, while for low-risk tasks, more concise segments can be chosen. It should be understood that the specific content of context constraints can be configured according to the actual application scenario, and this application does not limit this.

[0059] Necessary capability fragments refer to content segments extracted from the target business capability unit that are relevant to the current task focus and satisfy context constraints. Unlike existing technologies that inject the entire skill package, the capability fragments in this embodiment are dynamically selected. Metadata such as fragment indexes, dependency declarations, and capability nodes can be predefined within the target business capability unit. The local agent process dynamically calculates the set of fragments to be injected based on the current task focus and context constraints.

[0060] For example, the target business capability unit "asset-analyzer" can contain multiple fragments such as "asset analysis prompts," "customer information query templates," "report generation templates," and "compliance prompts." When the task focus is on "asset allocation recommendations" and the remaining keyword budget is limited, the local agent process can select "asset analysis prompts" and "customer information query templates" as necessary capability fragments, while omitting "report generation templates." When the task focus is on "generating analysis reports," then "report generation templates" and "compliance prompts" are selected. This dynamic selection mechanism ensures the accuracy and efficiency of the injected content, avoids interference from irrelevant information with the agent, and reduces the risk of sensitive information leakage.

[0061] Assembling capability fragments into context-enhanced content refers to the process by which the local agent process combines one or more selected capability fragments according to a preset format or template, performs operations such as parameter filling and desensitization, and generates the final content to be injected into the agent's context. The assembly process may include: replacing placeholders in the fragments with actual parameter values; desensitizing or summarizing sensitive information; adding necessary introductory text or separators; and concatenating multiple fragments in logical order. After assembly, the context-enhanced content is obtained, which will be injected into the agent's context as a guide for the agent to execute subsequent tasks.

[0062] Furthermore, after receiving the invocation request from the agent, the local agent process first constructs the task focus, then selects necessary capability fragments from the target business capability unit based on context constraints, assembles and generates context enhancement content, and finally returns it to the agent through the standard output channel. This process realizes the transformation from static full exposure to dynamic on-demand injection, effectively improving the efficiency of context utilization and the granularity of control.

[0063] When injecting the processing results into the context of the agent, this embodiment adopts a mechanism of separate output: the context enhancement content is returned to the agent through the standard output channel, and the context enhancement content and prompting information are output separately.

[0064] Specifically, the standard output channel and the standard error channel are two standard data streams provided by the operating system. In existing technologies, programs typically mix all output content together, resulting in a mixture of machine-readable content and human-readable prompts. This is not only detrimental to intelligent agent parsing but also easily leads to the leakage of sensitive information. In this embodiment, the structured machine-readable results of the local agent process are output to the standard output channel, while the agent process's own prompts, alarms, and error summaries are output to the standard error channel. When the structured results contain output fields from downstream scripts, the agent process can de-identify, summarize, or intercept sensitive content to prevent credentials, verification codes, access tokens, or sensitive client parameters from entering any output channel in complete plaintext form.

[0065] This embodiment achieves refined and dynamic context injection through a fragment selection mechanism based on task focus and context constraints, solving the problem of coarse-grained context injection in existing technologies. By separating the output of the standard output channel and the standard error channel, machine-readable content and human-readable prompts are separated, improving data parsing efficiency and reducing the risk of sensitive information leakage.

[0066] It should be understood that the above-described separation output mechanism is only a preferred implementation. In other embodiments, other inter-process communication mechanisms or data formats can also be used to achieve similar functions, as long as the separation of context-enhanced content and prompting information can be achieved.

[0067] In one alternative embodiment, the local agent process can run in two forms: a command-line process or a resident service process.

[0068] In the command-line process model, the operating system starts a new process instance to execute the task each time the agent initiates a call, and the process exits after the task is completed. The advantages of this model are its simplicity and low resource consumption, making it suitable for scenarios with low call frequency or limited resources.

[0069] The resident service process model involves a local agent process running as a background service in the operating system. The agent's invocation requests are sent to this resident service process for processing via inter-process communication mechanisms. The advantages of this model are fast response speed and efficient state maintenance in memory, making it suitable for scenarios requiring high-frequency calls or rapid responses. Those skilled in the art can choose a suitable process model based on the actual application scenario and performance requirements; this application does not impose any limitations on this.

[0070] The local agent process maintains the session state across agents by sharing a local state file. Depending on the process's running mode, corresponding concurrency control strategies are adopted: when the local agent process runs as a resident service process, a single service process serializes the processing of requests to maintain state consistency; when the local agent process runs as a short-lifecycle process such as a command-line process, file locks, transactional writes, or local database transaction mechanisms are used to ensure the consistency of concurrent access to the state file by multiple processes.

[0071] Specifically, the local state file is a persistent data file stored in the user's local file system, recording key information such as session state, authentication state, and metering state. Session state includes the context of the currently accessed service capability unit, such as which service capability unit the user is currently using, the unit's version number, and the session identifier. Authentication state includes the user's identity, authentication token, and permission information. Metering state includes the user, service capability unit, and version triple quota, as well as metering data such as the number of uses and remaining uses.

[0072] Because the local state file exists independently of each agent, different agents are actually sharing the same state data when calling the same local agent entry point. This contrasts sharply with existing technologies where each agent independently holds a copy of its skills and maintains its own state, leading to fragmented control and miscalculation of quotas. This embodiment ensures state consistency and unified control through the single data source of the local state file.

[0073] Multiple agents access business capabilities through the same set of local agent programs; in short-lifecycle CLI mode, multiple calling instances maintain session, authentication, and visibility states by sharing local state files, and can combine file locks, transactional writes, or local database transactions to ensure concurrent consistency; in resident service mode, requests can be processed serially by a single service process.

[0074] In an optional embodiment, in order to resolve the potential state conflict problem that may occur when multiple smart agents make concurrent calls, the local state file uses file locks or atomic write mechanisms to ensure consistency during concurrent access.

[0075] File locking is a concurrency control mechanism provided by the operating system. When a local agent process needs to read or write a local state file, it first attempts to acquire an exclusive lock on the file. If successful, the read / write operation is performed, and the lock is released after completion. If acquisition fails, it indicates that another process is operating on the file, and the process waits or retryes. Atomic write mechanism, on the other hand, means that when writing to the local state file, the original file is not directly overwritten. Instead, a temporary file is written first. After the writing is complete and its integrity is verified, the temporary file replaces the original file through the operating system's atomic renaming operation. This method avoids file corruption due to abnormal situations such as process crashes or system power outages, ensuring the integrity of state data.

[0076] It should be understood that the file locking and atomic write mechanisms described above are only preferred implementations. In other embodiments, other concurrency control mechanisms such as local database transactions and in-memory databases can also be used, as long as the consistency of state data can be guaranteed when multiple processes access it concurrently. In some embodiments, the local state file can also be written sequentially, triggered serially by short-lifecycle calls.

[0077] In addition, the local agent process maintains metering status, which includes triplet quotas for users, business capability units, and versions, and performs triplet quota verification for each call.

[0078] Specifically, when the local agent process receives a call request from the intelligent agent, it reads the current user's quota information for the target business capability unit from the local state file or remote management service to determine if there are any remaining call attempts or computing resources. If the quota is sufficient, the call is allowed and the corresponding quota is deducted. If the quota is insufficient, the call is rejected and a prompt message is returned. In this way, the manufacturer can precisely control each user's usage of each version of each business capability unit, thereby supporting business models such as paid subscriptions and pay-as-you-go billing.

[0079] This embodiment uses a local agent process as a unified management anchor point across agents, enabling centralized maintenance and cross-agent sharing of session state, authentication state, and metering state. File locks or atomic write mechanisms ensure consistency during concurrent access, while triplet quota verification achieves fine-grained metering control. These technologies work together to enable the manufacturer to implement consistent management strategies in a multi-agent environment, avoiding various problems caused by the dispersed nature of skill copies in traditional solutions.

[0080] Specifically, in this embodiment, the state machine verification object is the controlled business action initiated through the local agent process entry point, rather than generalized to intercepting all tool calls of the intelligent agent.

[0081] It should be understood that the local agent process does not intercept all tool calls in the agent host, nor does it take over the agent's complete execution loop in a general sense. It intercepts the execution path of the controlled business capabilities provided by this embodiment. Since the guidance skill does not directly expose business scripts, business interfaces, or business prompts, the agent must call the corresponding sub-command of the local agent process to use the business capabilities provided by this embodiment.

[0082] The local agent process simultaneously acts as a context provider and a controlled action gateway, and state machine verification occurs when the local agent process receives subsequent subcommands.

[0083] For example, once an agent has entered the asset analysis context, if it continues to invoke sub-commands for analysis or report generation, the local agent process will determine whether the action constitutes a legitimate state transition within the current business capability unit. If the agent attempts to invoke an action that does not belong to the current context, such as a fund transfer action, the local agent process will refuse to execute it and return correction information.

[0084] This embodiment does not advocate directly blocking all external tools that come with the agent. If the agent bypasses the local agent process to call other tools provided by the host platform, this embodiment does not advocate globally blocking these third-party tools.

[0085] In this embodiment, the business capabilities distributed by the manufacturer are no longer exposed as local skills that can be directly read and executed by the intelligent agent, but are instead converged to the controlled entry point of the local agent process.

[0086] The local agent process uses a state machine to verify whether the controlled business action belongs to the set of legal actions of the current business capability unit.

[0087] A set of legal actions refers to the set of actions that a business capability unit is allowed to perform in its current state. Its definition and state transition rules are pre-declared by the business capability unit's metadata. For example, an asset analysis business capability unit can define three states: initial state, in-analysis state, and report generation state. In the initial state, the set of legal actions includes entering analysis and querying customer information. In the in-analysis state, the set of legal actions includes performing analysis and generating a report. In the report generation state, the set of legal actions includes exporting the report and exiting.

[0088] State transition rules define the actions required to transition from one state to another. For example, performing an analysis action can transition the state from the initial state to the state under analysis. When the local agent process receives a controlled business action initiated by the agent, it first reads the state machine definition of the current business capability unit and the current session state, and then determines whether the action belongs to the set of legal actions in the current state. If it does, execution is allowed, and the session state is updated. If it does not, an unauthorized access handling process is triggered.

[0089] Specifically, in response to a controlled business action not belonging to the set of legal actions, the local agent process generates guidance prompts based on the current set of legal actions and the type of unauthorized action, using a preset correction template to guide the agent back to a legal state.

[0090] In this optional embodiment, when the local agent process determines that a controlled business action is unauthorized, it first refuses to execute the action to prevent actual harm. Then, the local agent process generates a correction prompt, clearly informing the agent why the action is not allowed, such as that the current state does not support the action or that the action is not within the scope of the current business capability unit.

[0091] In this embodiment, the method for guiding the agent back to a legitimate state is to generate counterfactual prompts through a local agent process. Counterfactual prompts not only indicate errors but also serve as a proactive intervention technique to address the illusions of a large model. When generating action sequences, the large model may generate action sequences that do not conform to business logic due to interfering information in the context or its own illusions. Counterfactual prompts help the large model correct its internal state and generate subsequent actions that conform to business logic by providing correct action examples or guiding questions.

[0092] For example, when an agent attempts to invoke a fund transfer action within an asset analysis context, the local agent process might return a counterfactual message: "The current context only supports asset analysis-related operations. To perform a fund transfer, please exit the current context and enter the fund transfer context." The agent can understand its error and generate the correct action sequence. If the agent repeatedly initiates unauthorized actions, it indicates that it may be in an abnormal state or under malicious attack. The local agent process triggers a circuit breaker mechanism, temporarily or permanently prohibiting the agent from invoking the current business capability unit and recording the abnormal behavior in the audit log to report to the remote management service, thus forming a closed-loop protection on the execution side.

[0093] This embodiment achieves closed-loop control of the agent's subsequent execution path through execution-side state machine constraints and counterfactual correction mechanisms. State machine verification ensures that only legitimate actions are executed, preventing risks associated with unauthorized operations. Counterfactual prompts proactively intervene in the generation process of the large model, guiding it back to a legitimate state and reducing the harm caused by illusions. The circuit breaker mechanism provides fallback protection in extreme cases. These techniques work together to effectively improve the security and reliability of agent capability management.

[0094] In enhanced embodiments, or in deployment scenarios that require compliance with financial regulations, pay-as-you-go billing, and canary deployment control, the local agent process can further maintain metering status, audit status, manual confirmation status, and task feedback status.

[0095] Specifically, in response to sensitive operations involving target business capability units, a manual confirmation process is triggered through the local agent process.

[0096] Sensitive operations refer to those involving fund changes, access to customer privacy data, or execution of high-risk business activities that require manual intervention and confirmation. During runtime, the local agent process identifies whether the currently invoked business capability unit or specific action constitutes a sensitive operation. This identification can be based on the business capability unit's metadata declaration, action name, parameter characteristics, or policy rules issued by the remote management service. If identified as a sensitive operation, a manual confirmation process is triggered.

[0097] The manual confirmation process includes two modes: a terminal interactive mode and a structured confirmation protocol in a non-interactive mode. In the terminal interactive mode, the local agent process outputs a confirmation prompt through the standard error channel and obtains the user's confirmation command from the standard input channel.

[0098] In non-interactive mode, such as when the agent automatically invokes the local agent process in the background, or in scenarios where the user cannot directly input confirmation commands on the terminal, the local agent process employs a structured confirmation protocol. This protocol is not a simple pop-up prompt, but a complete closed-loop process.

[0099] Specifically, the local agent process first suspends the execution of sensitive operations and returns a structured confirmation request through the standard output channel. This request includes information such as the operation type, risk level, anonymized key parameters, confirmation message, confirmation request identifier, and expiration time. Upon receiving this structured confirmation request, the agent or its host front-end renders it to the user.

[0100] After the user confirms on the interface, the agent invokes the local agent process again, carrying a confirmation request identifier and a one-time confirmation token. The local agent process verifies whether the confirmation request identifier exists, whether it has expired, whether the parameter digest matches, and whether the user's identity matches. Only after the verification passes does the local agent process continue to execute sensitive operations and write the confirmation process to the audit log to ensure the integrity and security of manual confirmation and prevent the confirmation process from being bypassed or forged.

[0101] Furthermore, the local agent process records the confirmation process and call events to the audit log, and asynchronously reports the audit log to the remote management service.

[0102] The audit log records include, but are not limited to, one or more of the following: user identifier, session identifier, business capability unit name and version, specific action called, action parameters, call timestamp, call result, whether sensitive operations are involved, manual confirmation process records, or abnormal information.

[0103] The audit logs employ an asynchronous reporting mechanism. The local agent process first writes the audit logs to a local log file or message queue, and then a background thread or independent process periodically or in batches when network conditions permit, reports them to the remote management service. This asynchronous mechanism avoids blocking business call processes during audit reporting, improving system response speed and availability.

[0104] In addition, the local agent process evaluates the task state and constructs a runtime decision state vector based on the task state. The task state includes: the continuous success rate of the task within a set time window based on local audit log statistics, the version stability index synchronized from the remote management service, the remaining context length read from the agent context interface, and the risk level obtained by matching preset rules based on the current operation type and user identity.

[0105] Task state is a multi-dimensional set of states reflecting the current task execution status and operating environment. Task success rate refers to the proportion of tasks successfully executed within a recent period, used to assess the stability of the current business capability unit.

[0106] Version stability refers to the failure rate or anomaly rate of the currently used business capability unit version, and is used to evaluate version quality.

[0107] The remaining context length refers to the number of available lexical units remaining in the agent's current dialogue context, used to assess whether it is necessary to prune the injected content or switch to a lightweight version.

[0108] The risk level is a risk score that is comprehensively assessed based on user identity, operation type, environmental factors, etc., and is used to determine whether stronger control is needed or manual confirmation is required.

[0109] The local agent process constructs a runtime decision state vector from the state values ​​of the above multiple dimensions, which serves as the input for subsequent dynamic policy adjustments.

[0110] Based on runtime decision state vectors, execution strategies are dynamically adjusted through local agent processes. The execution strategies include at least one of canary version switching, quota elastic adjustment, and capability degradation.

[0111] Dynamic adjustment refers to adjusting the execution method of business capabilities in real time based on the task status during runtime, rather than relying on static configuration. For example, when the continuous success rate of a task falls below a preset threshold, the local agent process can trigger a circuit breaker mechanism, temporarily prohibiting calls to that business capability unit and reporting the exception to the remote management service. When version stability is low, the local agent process can automatically switch to a more stable older version. When the remaining context length is insufficient, the local agent process can enable a capability degradation strategy, injecting only core prompt word fragments and omitting examples and background knowledge. When the risk level is high, the local agent process can force the triggering of a manual confirmation process or reduce the quota. These dynamic adjustment strategies can be used in combination, enabling the system to adaptively respond to various runtime conditions, improving system robustness and user experience.

[0112] The financial compliance interception mechanism achieves closed-loop manual confirmation and audit traceability for sensitive operations, meeting the regulatory requirements of highly compliant scenarios such as finance. The task-state adaptive control mechanism enables dynamic strategy adjustments based on real-time status, improving system stability and resource utilization efficiency. It should be understood that the specific implementation methods of the above-mentioned manual confirmation process and task-state evaluation are only preferred embodiments. In other embodiments, the steps of the confirmation process or the evaluation dimensions of the task state can be adjusted according to actual business needs, as long as runtime compliance interception and adaptive control can be achieved.

[0113] The above describes the agent capability management method in the embodiments of this application. The following describes the agent capability management device in the embodiments of this application. Please refer to [link / reference]. Figure 2 One embodiment of the intelligent agent capability management device 400 in this application includes: Entry skill module 410 is used to respond to capability call requests initiated by the agent based on entry skills and obtain the set of visible capabilities of the current user through the local agent process.

[0114] The local agent process module 420 is used to obtain target business capability units from the local hosting area through the local agent process based on the visible capability set. The local hosting area is located outside the skill search path of the intelligent agent.

[0115] The business capability hosting module 430 is used to establish the runtime context of the target business capability unit through the local agent process and return the context content or execution result related to this call to the agent.

[0116] The business capability hosting module 430 is also used to select necessary fragments from the target business capability unit and assemble them into context-enhanced content based on task focus, context constraints and business capability unit metadata.

[0117] The business capability hosting module 430 is further used to return context-enhanced content to the agent through the standard output channel and to output context-enhanced content and prompting information separately.

[0118] The intelligent agent capability management device 400 also includes: The session authentication state maintenance module 440 is used to maintain the session state and authentication state shared across agents through the local agent process. The session state includes the context of the currently entered business capability unit. The local agent process runs in the form of a command line process or a resident service process. It realizes state sharing across agents through a local state file. The local state file uses file locks or atomic write mechanisms to ensure the consistency of concurrent access.

[0119] The metering status maintenance module 450 is used to maintain the metering status through a local agent process. The metering status includes the triplet quota for user, business capability unit and version, and performs triplet quota verification for each call.

[0120] The intelligent agent capability management device 400 also includes: The receiving module is used to receive controlled business actions initiated by the intelligent agent through the local agent process.

[0121] The verification module is used to verify, based on a state machine, whether a controlled business action belongs to the set of legal actions of the current business capability unit.

[0122] The correction module is used to respond to a controlled business action that does not belong to the set of legal actions. Based on the current set of legal actions and the type of the unauthorized action, it generates guidance prompt information through a preset correction template to guide the agent back to the legal state.

[0123] The intelligent agent capability management device 400 also includes: The manual confirmation module is used to trigger a manual confirmation process through a local agent process in response to sensitive operations involving the target business capability unit.

[0124] The log synchronization module is used to record the confirmation process and call events to the audit log, and asynchronously report the audit log to the remote management service.

[0125] The intelligent agent capability management device 400 also includes: The task state evaluation module is used to evaluate the task state through the local agent process and build a runtime decision state vector based on the task state. The task state includes the task success rate, version stability, remaining context length, and risk level.

[0126] The strategy adjustment module is used to dynamically adjust the execution strategy through the local agent process based on the runtime decision state vector. The execution strategy includes at least one of gray-scale version switching, quota elastic adjustment, and capability degradation.

[0127] above Figure 2 The intelligent agent capability management device in this application embodiment is described in detail from the perspective of modular functional entities. The computer device in this application embodiment is described in detail from the perspective of hardware processing.

[0128] Figure 3 This is a schematic diagram of the structure of a computer device 500 provided in an embodiment of this application. The computer device 500 can vary significantly due to different configurations or performance. It may include one or more central processing units (CPUs) 510 (e.g., one or more processors) and a memory 520, and one or more storage media 530 (e.g., one or more mass storage devices) for storing application programs 533 or data 532. The memory 520 and storage media 530 can be temporary or persistent storage. The program stored in the storage media 530 may include one or more modules (not shown in the diagram), each module including a series of instruction operations on the computer device 500. Furthermore, the processor 510 may be configured to communicate with the storage media 530 and execute the series of instruction operations in the storage media 530 on the computer device 500.

[0129] Computer device 500 may also include one or more power supplies 540, one or more wired or wireless network interfaces 550, one or more input / output interfaces 560, and / or one or more operating systems 531, such as Windows Server, Mac OSX, Unix, Linux, FreeBSD, etc. Those skilled in the art will understand that... Figure 3 The computer device structure shown does not constitute a limitation on the computer device and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0130] This application also provides a computer device, which includes a memory and a processor. The memory stores computer-readable instructions. When the computer-readable instructions are executed by the processor, the processor performs the steps of the intelligent agent capability management method in the above embodiments.

[0131] This application also provides a computer-readable storage medium, which can be a non-volatile computer-readable storage medium or a volatile computer-readable storage medium. The computer-readable storage medium stores instructions that, when executed on a computer, cause the computer to perform the steps of the intelligent agent capability management method.

[0132] Unlike existing technologies, this application addresses the problems of uncontrolled distribution of agent skills, exposure of intellectual property rights, and fragmented cross-platform management. Its core innovation lies in migrating the capability control point from distribution time to runtime. This application adopts a decoupled architecture between entry skills and business capabilities. Entry skills contain only routing conventions, while business capability units are stored in a local managed area outside the agent's search path, intentionally omitting discovery description files. This approach ensures that business capabilities physically exist but are semantically invisible to the agent, effectively protecting core intellectual property rights and eliminating strong dependence on platform distribution channels. This application also introduces a local agent process as a unified management anchor. The agent process exclusively maintains the shared session, authentication, and metering states across agents, ensuring concurrency consistency through file locks and atomic writes, and performing triplet quota verification. This breaks the state fragmentation caused by the independent holding of these states by each agent, achieving a consistent metering, authentication, and auditing view across agents. This application also implements dynamic injection and pruning of runtime context. The agent process selects necessary fragment combinations for injection based on the current task focus and context constraints, and separates machine-readable enhancement content from human-readable prompts for output. This avoids full plaintext exposure, improves context utilization efficiency, and prevents the leakage of sensitive information beyond its scope. This application also establishes execution-side closed-loop protection and task-state adaptive control. Controlled actions are verified through a state machine; when an action exceeds its authority, corrective measures and counterfactual warnings are triggered, and circuit breakers are activated, effectively defending against model illusions. Sensitive operations trigger a manual confirmation closed loop to meet financial compliance requirements. Simultaneously, a decision vector is constructed based on the task state, dynamically adjusting grayscale, degradation, and other strategies to achieve adaptive risk convergence based on the actual task state.

[0133] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on its differences from other embodiments. In particular, the storage medium embodiments and computer device embodiments are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0134] This application can be used in a wide range of general-purpose or special-purpose computing system environments or configurations. For example: personal computers, handheld or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, network PCs, minicomputers, distributed computing environments including any of the above systems or devices, etc.

[0135] In the several embodiments provided in this application, it should be understood that the disclosed methods and devices can be implemented in other ways. For example, the device embodiments described above are merely illustrative; multiple units or components may be combined or integrated into another system, or some features may be omitted or not performed.

[0136] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment, depending on actual needs.

[0137] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0138] The above description is merely an embodiment of this application and does not limit the patent scope of this application. Any equivalent structural or procedural transformations made using the content of this application's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of this application.

Claims

1. A method for controlling the capabilities of an intelligent agent, characterized in that, include: In response to a capability call request initiated by an intelligent agent based on an entry skill, the set of visible capabilities of the current user is obtained through the local agent process; Based on the set of visible capabilities, the target business capability unit is obtained from the local hosting area through the local agent process, and the local hosting area is located outside the skill search path of the intelligent agent. The local agent process establishes the runtime context of the target business capability unit and returns the context content or execution result related to this call to the agent.

2. The intelligent agent capability control method according to claim 1, characterized in that, The intelligent agent capability management method also includes: The local agent process maintains the shared session state and authentication state across agents. The session state includes the context of the currently entered business capability unit. The local agent process runs as a command line process or a resident service process. It achieves state sharing across agents through a local state file. The local state file uses file locks or atomic write mechanisms to ensure consistency of concurrent access. The metering status is maintained through the local agent process. The metering status includes the triplet quota for user, business capability unit and version, and the triplet quota is verified for each call.

3. The intelligent agent capability control method according to claim 1, characterized in that, The step of establishing the runtime context of the target business capability unit through the local agent process includes: Based on task focus, context constraints, and business capability unit metadata, necessary fragments are selected from the target business capability unit and assembled into context-enhanced content.

4. The intelligent agent capability control method according to claim 3, characterized in that, Returning context content or execution results related to this call to the agent includes: The context-enhanced content is returned to the agent through the standard output channel, and the context-enhanced content is output separately from the prompting information.

5. The intelligent agent capability control method according to claim 1, characterized in that, The intelligent agent capability management method also includes: The local agent process receives controlled business actions initiated by the intelligent agent. The state machine is used to verify whether the controlled service action belongs to the set of legal actions of the current service capability unit; In response to the controlled business action not belonging to the set of legal actions, based on the current set of legal actions and the type of the unauthorized action, a guidance prompt message is generated through a preset correction template to guide the agent back to the legal state.

6. The intelligent agent capability control method according to claim 1, characterized in that, The intelligent agent capability management method also includes: In response to the target business capability unit involving sensitive operations, a manual confirmation process is triggered through the local agent process; Record the confirmation process and call events to the audit log, and asynchronously report the audit log to the remote management service.

7. The intelligent agent capability control method according to claim 1, characterized in that, The intelligent agent capability management method also includes: The task state is evaluated through the local agent process, and a runtime decision state vector is constructed based on the task state; Based on the runtime decision state vector, the execution strategy is dynamically adjusted through the local agent process. The execution strategy includes at least one of gray-scale version switching, quota elastic adjustment, and capability degradation.

8. A device for controlling the capabilities of an intelligent agent, characterized in that, include: The entry skill module is used to respond to capability call requests initiated by the agent based on the entry skill and obtain the set of visible capabilities of the current user through the local agent process; A local agent process module is used to obtain target business capability units from a local hosting area through the local agent process based on the visible capability set, wherein the local hosting area is located outside the skill search path of the intelligent agent; The business capability hosting module is used to establish the running context of the target business capability unit through the local agent process, and return the context content or execution result related to this call to the agent.

9. A computer device, characterized in that, The computer device includes: a memory and at least one processor, wherein the memory stores instructions; The at least one processor invokes the instructions in the memory to cause the computer device to execute the agent capability management method as described in any one of claims 1-7.

10. A computer-readable storage medium storing instructions thereon, characterized in that, When the instruction is executed by the processor, it implements the agent capability management method as described in any one of claims 1-7.

Images