A multi-agent collaborative construction system and method based on feature space orthogonalization

Abstract

The application provides a multi-agent collaborative construction system and method based on feature space orthogonalization, which comprises an input layer including an agent definition table and a skill definition table, a processing layer including a function vectorization module, an orthogonal degree calculation module and a team selection module, and a running layer including a task routing module, a session isolation module and a persistent configuration module; the task routing module includes execution task vectorization, collaborative routing and conflict resolution, the execution task vectorization is used for mapping an input task to the same function feature space as an agent function vector, the collaborative routing is used for reading a dimension-level decision priority matrix, combining the matching results between a task vector and an agent function vector, and selecting a leading agent and an auxiliary agent, and the conflict resolution is used for executing a ruling according to the dimension-level decision priority matrix when the outputs of multiple agents on the same function dimension are inconsistent.

Description

Technical Field

[0001] This invention relates to the field of multi-agent architecture technology, and more specifically, to a multi-agent collaborative construction system and method based on feature space orthogonalization. Background Technology

[0002] With the development of large-scale models, tool calls, process orchestration, and automated decision-making technologies, a single agent can no longer cover all task requirements in complex systems. To improve system scalability and specialized processing capabilities, more and more computer systems are adopting a multi-agent architecture, configuring different agents with different roles and binding them with different skills, prompts, tools, session contexts, and execution permissions. A typical system maintains a set of agent definitions, each with a unique code, name, category, summary description, detailed description, type tag, start / stop status, and sorting field; the system also maintains skill definitions, each skill is bound to a specific agent and includes a skill code, skill name, skill description, skill type, system prompt, and initial response text. Users or upper-level task systems can select several agents from the agent directory to form a team, and at runtime, create independent sessions, save message records, and perform task interactions according to agent identifiers and skill identifiers.

[0003] In real-world engineering implementations, the key to multi-agent collaboration is not simply having a larger number of agents, but rather ensuring clear functional boundaries between them. If multiple agents can make high-confidence decisions for the same task, the system is prone to problems such as duplicate responses, overlapping, decision-making inefficiencies, and unclear responsibility attribution. Conversely, if agent boundaries are too narrow, complex tasks require frequent manual switching, making it difficult to form stable collaborative links. Existing multi-agent systems typically rely on human experience to name agents and write job descriptions, lacking computable modeling of functional boundaries. Even if the system configuration specifies that an agent is responsible for a certain type of task or not, this boundary is usually just a natural language constraint and is not mapped to a computable feature vector. Therefore, when the descriptive text, skill descriptions, or tool permissions of multiple agents overlap semantically, the system struggles to identify overlapping areas during the architecture construction phase and to quantify whether the functional angle between two agents is sufficiently close to orthogonal.

[0004] Existing systems lack a global orthogonalization mechanism for heterogeneous agent sets. Multi-agent teams are often formed through simple selection, start / stop switches, or sorting fields. At best, the system can guarantee that the code of the same agent under the same subject is not repeated, but it cannot guarantee low overlap between agents in the functional space. This can lead to two or more agents simultaneously having the right to respond in the same task dimension, thus increasing the decision-making cost of the upper-level coordinator. In complex tasks, functional overlap can also cause multiple rounds of mutual correction, iterative decisions, and unstable final results.

[0005] Furthermore, existing collaborative routing typically relies solely on explicit selection or fixed ordering, lacking rules for establishing the highest decision priority within functional dimensions. When the input task involves multiple functional domains simultaneously, the system needs to determine which subtasks should be led by which agent, and which agents should only provide auxiliary opinions. Without a priority matrix based on feature space, the system is prone to unclear leadership, especially when multiple agents can handle parts of the content in the same session, making it difficult to reliably determine the final decision-maker. Summary of the Invention

[0006] To address the shortcomings of existing technologies, the present invention aims to provide a multi-agent collaborative construction system and method based on feature space orthogonalization. By representing the capability boundaries of agents in a multi-dimensional functional space, the system can quantify the angles and overlaps between agents, thereby identifying responsibility overlap issues during the architecture construction phase. Compared with schemes that rely solely on manual naming, textual descriptions, or fixed ordering, the present invention can more accurately construct a set of heterogeneous agents with low overlap.

[0007] To solve the above problems, the technical solution of the present invention is as follows:

[0008] A multi-agent cooperative construction system based on feature space orthogonalization includes:

[0009] The input layer includes the agent definition table and the skill definition table;

[0010] The processing layer includes a function vectorization module, an orthogonality calculation module, and a team selection module. The function vectorization module converts agent definitions, skill definitions, prompts, tool permissions, and historical effects into function vectors. The orthogonality calculation module calculates the angle and overlap between any two agents. The team selection module selects a set of agents with low overlap and sufficient coverage. After completing the agent team selection, the system generates a dimension-level decision priority matrix based on the relative capabilities of the selected agents in each functional dimension.

[0011] The runtime layer includes a task routing module, a session isolation module, and a persistent configuration module. The task routing module includes task vectorization, collaborative routing, and conflict resolution. Task vectorization maps input tasks to the same functional feature space as the agent's function vector. Collaborative routing reads the dimension-level decision priority matrix and, based on the matching results between the task vector and the agent's function vector, selects the leading and auxiliary agents. Conflict resolution, when multiple agents have inconsistent outputs on the same functional dimension, makes a decision based on the dimension-level decision priority matrix. The session isolation module maintains context by agent and skill. The persistent configuration module stores agent definitions, skill boundaries, team members, and versioned configurations.

[0012] Preferably, the function vectorization module aggregates the skill definitions associated with each agent according to the agent encoding, and extracts positive and negative responsibility features from the agent description, skill description, system prompts and tool permissions. The positive responsibility features are mapped to the enhancement weights of the corresponding function dimensions, and the negative responsibility features are mapped to the inhibition weights of the corresponding function dimensions, thereby generating the original function vectors of each agent.

[0013] Preferably, the orthogonality calculation module normalizes the original function vectors of each agent, calculates the cosine overlap and function angle between any two agents, and determines whether the two agents are approximately orthogonal based on a preset orthogonality threshold.

[0014] Preferably, the team selection module calculates the target functional dimension coverage gain and the highest residual overlap of the candidate agents relative to the set of selected agents. For candidate agents whose highest residual overlap does not exceed the orthogonality threshold, agents to be added to the team are determined according to the coverage gain, the highest residual overlap, and the sorting field. For candidate agents whose highest residual overlap exceeds the orthogonality threshold, they are marked as auxiliary agents or excluded from the current team candidates. The above process is repeated until the target functional dimension coverage condition is met or the preset team size is reached.

[0015] Furthermore, the present invention also provides a multi-agent cooperative construction method based on feature space orthogonalization, comprising the following steps:

[0016] The system first reads all enabled agents from the agent definition table and then reads all enabled skills from the skill definition table;

[0017] Extract the original function vector for each agent;

[0018] Normalize all vectors and calculate the cosine overlap between any two agents;

[0019] Determine whether the overlap between two agents exceeds a threshold;

[0020] Output orthogonal intelligent agent team.

[0021] Preferably, in the steps of the system first reading all enabled agents from the agent definition table and then reading all enabled skills from the skill definition table, each agent definition includes a unique agent code, name, category, description, type, start / stop status, and sorting field. Each skill definition includes a bound agent code, skill code, skill name, skill description, skill type, system prompt, welcome message, start / stop status, and sorting field. The system aggregates the skill definitions in the enabled state to the corresponding agents according to the agent code.

[0022] Preferably, the step of extracting the original function vector of each agent specifically includes: the system aggregating the corresponding enabled skills according to the agent's encoding, extracting function features from agent category, agent description, skill type, skill description and system prompt words; identifying clearly responsible functional domains as positive responsibility features, identifying clearly non-handled or prohibited functional domains as negative responsibility features, and generating the original function vector based on the basic score, positive enhancement value and negative inhibition value of each function dimension.

[0023] Preferably, the step of normalizing all vectors and calculating the cosine overlap between any two agents specifically includes: the system maintaining multiple candidate agents, whose functional dimensions include process planning, tool invocation, text generation, rule interpretation and risk control; the system calculating a five-dimensional vector for each candidate agent and calculating the cosine overlap between any two agents.

[0024] Preferably, the step of determining whether the overlap between two agents exceeds a threshold specifically includes: when the overlap between two agents exceeds an orthogonal threshold, determining the primary agent based on the ranking weight, skill coverage, and the highest residual overlap of each agent relative to the selected agent set, and marking the other agent as an auxiliary agent or excluding it from the current team candidates.

[0025] Preferably, the step of outputting the orthogonalized intelligent agent team specifically includes: after the team is formed, generating a decision priority matrix based on the relative capabilities of each member in different functional dimensions, transforming the dominance, assistance, and sharing relationships of functional dimensions into runtime executable rules, so that the low-overlapping team structure can maintain the boundaries of responsibilities during continuous operation, and providing verifiable and reviewable data for subsequent updates of functional vectors and evaluation of collaborative effects, and finally writing the team members into the team relationship table.

[0026] Compared with the prior art, the present invention has the following beneficial effects:

[0027] 1. This invention elevates the role responsibilities in multi-agent systems from natural language configuration to computable function vectors. By representing the capability boundaries of agents in a multi-dimensional function space, the system can quantify the angles and overlaps between agents, thereby identifying responsibility overlap issues during the architecture construction phase. Compared to schemes that rely solely on manual naming, textual descriptions, or fixed ordering, this invention can more accurately construct a set of heterogeneous agents with low overlap.

[0028] 2. This invention reduces the internal friction of multi-agent decision-making by using approximate orthogonal constraints. When selecting team members, the system considers both functional domain coverage and overlap penalty, so that the agents in the final set can assume the main functions in different functional dimensions as much as possible. This can reduce the probability of multiple agents giving dominant opinions on the same task at the same time, and reduce the risks of repeated responses, mutual corrections and unstable final decisions.

[0029] 3. By generating a priority matrix, the system can clearly identify which functional domains each agent has the highest decision priority. When a task spans multiple functional domains, the system can automatically split the task dimensions and assign the sub-tasks to the most suitable agent according to the dimension priority, thereby realizing the execution mode of "domain-based dominance and collaborative aggregation".

[0030] 4. The existing system already has basic structures such as agent definition, skill definition, system prompt words, team relationships, start / stop ordering, session isolation, and message persistence. This invention adds function vectorization, orthogonality calculation, team selection, and priority routing on top of these structures to form a complete solution. It does not depend on specific industry objects and can be applied to various computer application scenarios such as task automation, knowledge management, process control, content generation, tool orchestration, enterprise collaboration, and intelligent customer service. Attached Figure Description

[0031] Other features, objects, and advantages of the present invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings:

[0032] Figure 1 This is a block diagram of the multi-agent collaborative construction system based on feature space orthogonality of the present invention.

[0033] Figure 2 This is a schematic diagram of the functional space orthogonalization process;

[0034] Figure 3 This is a schematic diagram of a dimensional decision priority matrix;

[0035] Figure 4 A schematic diagram of the task coordination routing process;

[0036] Figure 5 This is a schematic diagram illustrating the data structure relationships involved in the project implementation.

[0037] Figure 6 A comparison diagram of the functional distribution of agent teams before and after orthogonalization;

[0038] Figure 7 This is a flowchart of the multi-agent collaborative construction method based on feature space orthogonalization according to the present invention. Detailed Implementation

[0039] The present invention will now be described in detail with reference to specific embodiments. These embodiments will help those skilled in the art to further understand the present invention, but do not limit the invention in any way. It should be noted that those skilled in the art can make several changes and improvements without departing from the concept of the present invention. These all fall within the protection scope of the present invention.

[0040] Specifically, this invention provides a multi-agent collaborative construction system based on feature space orthogonalization, such as... Figures 1 to 6 As shown, the system includes an input layer, a processing layer, and an execution layer. The input layer includes an agent definition table and a skill definition table; the processing layer includes a function vectorization module, an orthogonality calculation module, and a team selection module; and the execution layer includes a task routing module, a session isolation module, and a persistent configuration module.

[0041] The function vectorization module converts agent definitions, skill definitions, prompts, tool permissions, and historical effects into function vectors; the orthogonality calculation module calculates the angle and overlap between any two agents; and the team selection module selects a set of agents with low overlap and sufficient coverage. After completing the agent team selection, the system generates a dimension-level decision priority matrix based on the relative capabilities of the selected agents in each functional dimension.

[0042] The task routing module includes task vectorization, cooperative routing, and conflict resolution. Task vectorization maps the input task to a functional feature space identical to the agent's functional vector. Cooperative routing reads the dimension-level decision priority matrix and, based on the matching result between the task vector and the agent's functional vector, selects the leading agent and auxiliary agents. Conflict resolution, when multiple agents have inconsistent outputs on the same functional dimension, makes a decision based on the dimension-level decision priority matrix.

[0043] The session isolation module is used to maintain context by agent and skill; the persistent configuration module is used to save agent definitions, skill boundaries, team members and versioned configurations.

[0044] This invention first extracts the original descriptions of agents from agent directories, skill directories, tool capabilities, system prompts, role descriptions, start / stop status, sorting fields, and team configurations, converting each agent into a function vector. This function vector resides in an N-dimensional function feature space, where each dimension represents a computable functional domain, such as domain processing capability, tool invocation capability, process planning capability, risk control capability, content generation capability, resource retrieval capability, emotion recognition capability, rule interpretation capability, image generation capability, or long-term context maintenance capability. When constructing the agent set, the system no longer simply checks the uniqueness of agent encodings but calculates the angle between any two agent function vectors, ensuring that agents selected for the same collaborative architecture satisfy approximately orthogonal constraints. For input tasks, the system also encodes them as task vectors and determines the dominant and auxiliary agents based on the projection values ​​of the task vectors and the function vectors of each agent. For tasks with multiple functional domains, the system determines which agent has the highest decision priority for each dimension based on a dimension-level priority matrix, thereby achieving a low-conflict, interpretable, and persistent heterogeneous agent collaborative architecture.

[0045] At any given time, the system maintains a set of candidate agents, where each agent contains at least an agent code, type, category, description, skill set, prompt word constraints, tool permissions, activation status, and ranking weight. The system defines a function feature space and constructs a function vector for each agent. The function vector can be obtained by combining the agent description, skill description, responsibility boundaries in the prompt words, tool type, and historical call effects. The function vectorization module aggregates the skill definitions associated with each agent according to the agent code, and extracts positive and negative responsibility features from the agent description, skill description, system prompt words, and tool permissions. The positive responsibility features are mapped to enhancement weights of the corresponding function dimensions, and the negative responsibility features are mapped to inhibition weights of the corresponding function dimensions, thereby generating the original function vector for each agent.

[0046] To measure the degree of functional overlap between two agents, the orthogonality calculation module normalizes the original functional vectors of each agent and calculates the cosine overlap and functional angle between any two agents. The system can preset an orthogonality threshold and determine whether the two agents are approximately orthogonal based on the preset orthogonality threshold.

[0047] The team selection module calculates the target function dimension coverage gain and the highest residual overlap of the candidate agents relative to the set of selected agents. For candidate agents whose highest residual overlap does not exceed the orthogonality threshold, agents to be added to the team are determined according to the coverage gain, the highest residual overlap, and the sorting field. For candidate agents whose highest residual overlap exceeds the orthogonality threshold, they are marked as auxiliary agents or excluded from the current team candidates. The above process is repeated until the target function dimension coverage condition is met or the preset team size is reached.

[0048] After completing the selection of the agent set, the system generates a dimension-level decision priority matrix. Through this matrix, the system can convert "who is responsible for what" from natural language descriptions into executable dimension-level permission rules, and transform the dominance, assistance and sharing relationships of functional dimensions into runtime executable rules. This enables low-overlap team structures to maintain responsibility boundaries during continuous operation and provides verifiable and reviewable data for subsequent updates to functional vectors and evaluation of collaborative effects. The final team members are then written into the team relationship table.

[0049] In terms of engineering implementation, the agent directory table in the existing codebase corresponds to the candidate agent set of this invention, the skill definition table corresponds to the skill descriptions and system prompts required for function vector generation, and the user agent team relationship table corresponds to the persistent records of the final agent set. The directory service queries agent definitions by status and sorting fields, then aggregates skill definitions by agent code, and returns a data structure containing agent code, category, description, type, and skill list to the front end. The session service carries agent identifier, skill identifier, subject identifier, and session identifier when receiving a request, and stores the message in isolation according to agent identifier and skill identifier. The front-end interaction component injects system prompts into the message sequence according to the selected agent and skill, and sends the agent identifier and skill identifier with the request.

[0050] Furthermore, the present invention also provides a multi-agent cooperative construction method based on feature space orthogonalization, such as... Figure 7 As shown, the method includes the following steps:

[0051] S1: The system first reads all enabled agents from the agent definition table and all enabled skills from the skill definition table;

[0052] Specifically, each agent definition includes a unique code, category, description, type, start / stop status, and sorting field, while each skill definition includes a skill code, skill name, skill description, skill type, system prompt, and initial response text.

[0053] During runtime, the front-end component retrieves the set of agents and skills from the directory interface and creates an interactive window after the user selects an agent and skill. For text-based skills, the front-end inserts the system prompt for the skill into the message sequence, and then sends it to the back-end along with the agent identifier, skill identifier, subject identifier, and session identifier. The back-end session service parses or creates a session based on the subject identifier, agent identifier, and skill identifier, writes the user message and agent response to the message table respectively, and saves the agent identifier, skill identifier, front-end session identifier, and round information in the message metadata. This implementation keeps different agents, skills, and session contexts isolated, providing a foundation for boundary preservation in orthogonal collaboration.

[0054] S2: Extract the original function vector for each agent;

[0055] Specifically, the system aggregates the corresponding enabled skills according to the agent's encoding, and extracts functional features from the agent category, agent description, skill type, skill description, and system prompt words; it identifies clearly responsible functional domains as positive responsibility features and clearly prohibited functional domains as negative responsibility features; based on the preset functional dimension dictionary and feature weights, it calculates the basic score, positive enhancement value, and negative inhibition value of each functional dimension, and arranges the scores of each dimension in a fixed order according to the functional dimensions to obtain the agent's original functional vector.

[0056] S3: Normalize all vectors and calculate the cosine overlap between any two agents;

[0057] In one specific embodiment, the system maintains five candidate agents, whose functional dimensions include process planning, tool invocation, text generation, rule interpretation, and risk control. The system calculates a five-dimensional vector for each candidate agent and calculates the cosine overlap between any two agents.

[0058] S4: Determine whether the overlap between the two agents exceeds the threshold;

[0059] Specifically, if the overlap between two agents exceeds the orthogonality threshold, the primary agent is determined based on the ranking weight, skill coverage, and the highest residual overlap of each agent relative to the selected agent set, and the other agent is marked as an auxiliary agent or excluded from the current team candidates.

[0060] S5: Output orthogonalized intelligent agent team.

[0061] Specifically, after the team is formed, a decision priority matrix is ​​generated based on the relative capabilities of each member in different functional dimensions. The dominance, assistance and sharing relationships of functional dimensions are transformed into runtime executable rules, so that the low-overlap team structure can maintain the boundaries of responsibilities in continuous operation and provide verifiable and reviewable data for subsequent updates of functional vectors and evaluation of collaborative effects. The team members are finally written into the team relationship table, recording subject identifier, agent code, name snapshot, activation status, sorting value and custom configuration.

[0062] Specific embodiments of the present invention have been described above. It should be understood that the present invention is not limited to the specific embodiments described above, and those skilled in the art can make various changes or modifications within the scope of the claims, which do not affect the essence of the present invention. Unless otherwise specified, the embodiments and features described in this application can be arbitrarily combined with each other.

Claims

1. A multi-agent collaborative construction system based on feature space orthogonalization, characterized in that, The system includes: The input layer includes the agent definition table and the skill definition table; The processing layer includes a function vectorization module, an orthogonality calculation module, and a team selection module. The function vectorization module converts agent definitions, skill definitions, prompts, tool permissions, and historical effects into function vectors. The orthogonality calculation module calculates the angle and overlap between any two agents. The team selection module selects a set of agents with low overlap and sufficient coverage. After completing the agent team selection, the system generates a dimension-level decision priority matrix based on the relative capabilities of the selected agents in each functional dimension. The runtime layer includes a task routing module, a session isolation module, and a persistent configuration module. The task routing module includes task vectorization, collaborative routing, and conflict resolution. Task vectorization maps input tasks to the same functional feature space as the agent's function vector. Collaborative routing reads the dimension-level decision priority matrix and, based on the matching results between the task vector and the agent's function vector, selects the leading and auxiliary agents. Conflict resolution, when multiple agents have inconsistent outputs on the same functional dimension, makes a decision based on the dimension-level decision priority matrix. The session isolation module maintains context by agent and skill. The persistent configuration module stores agent definitions, skill boundaries, team members, and versioned configurations.

2. The multi-agent collaborative construction system based on feature space orthogonality according to claim 1, characterized in that, The function vectorization module aggregates the skill definitions associated with each agent according to the agent encoding, and extracts positive and negative responsibility features from agent descriptions, skill descriptions, system prompts and tool permissions. The positive responsibility features are mapped to the enhancement weights of the corresponding function dimensions, and the negative responsibility features are mapped to the inhibition weights of the corresponding function dimensions, thereby generating the original function vectors of each agent.

3. The multi-agent collaborative construction system based on feature space orthogonality according to claim 1, characterized in that, The orthogonality calculation module normalizes the original function vectors of each agent, calculates the cosine overlap and function angle between any two agents, and determines whether the two agents are approximately orthogonal based on a preset orthogonality threshold.

4. The multi-agent collaborative construction system based on feature space orthogonality according to claim 1, characterized in that, The team selection module calculates the target function dimension coverage gain and the highest residual overlap of the candidate agents relative to the set of selected agents. For candidate agents whose highest residual overlap does not exceed the orthogonality threshold, agents to be added to the team are determined according to the coverage gain, the highest residual overlap, and the sorting field. For candidate agents whose highest residual overlap exceeds the orthogonality threshold, they are marked as auxiliary agents or excluded from the current team candidates. The above process is repeated until the target function dimension coverage condition is met or the preset team size is reached.

5. A multi-agent collaborative construction method based on feature space orthogonalization, characterized in that, The method includes the following steps: The system first reads all enabled agents from the agent definition table and then reads all enabled skills from the skill definition table; Extract the original function vector for each agent; Normalize all vectors and calculate the cosine overlap between any two agents; Determine whether the overlap between two agents exceeds a threshold; Output orthogonal intelligent agent team.

6. The multi-agent cooperative construction method based on feature space orthogonality according to claim 5, characterized in that, In the steps of the system first reading all enabled agents from the agent definition table and then reading all enabled skills from the skill definition table, each agent definition includes a unique agent code, name, category, description, type, start / stop status, and sorting field. Each skill definition includes a bound agent code, skill code, skill name, skill description, skill type, system prompt, welcome message, start / stop status, and sorting field. The system aggregates the skill definitions in the enabled state to the corresponding agents according to the agent code.

7. The multi-agent cooperative construction method based on feature space orthogonality according to claim 5, characterized in that, The step of extracting the original function vector for each agent specifically includes: the system aggregating the corresponding enabled skills according to the agent's encoding, extracting function features from agent category, agent description, skill type, skill description and system prompt words; identifying clearly responsible functional domains as positive responsibility features, identifying clearly non-handled or prohibited functional domains as negative responsibility features, and generating the original function vector based on the basic score, positive enhancement value and negative inhibition value of each function dimension.

8. The multi-agent cooperative construction method based on feature space orthogonality according to claim 5, characterized in that, The steps of normalizing all vectors and calculating the cosine overlap between any two agents specifically include: the system maintains multiple candidate agents, whose functional dimensions include process planning, tool invocation, text generation, rule interpretation, and risk control; the system calculates a five-dimensional vector for each candidate agent and calculates the cosine overlap between any two agents.

9. The multi-agent cooperative construction method based on feature space orthogonality according to claim 5, characterized in that, The step of determining whether the overlap between two agents exceeds the threshold specifically includes: when the overlap between two agents exceeds the orthogonality threshold, determining the primary agent based on the ranking weight, skill coverage, and the highest residual overlap of each agent relative to the selected agent set, and marking the other agent as an auxiliary agent or excluding it from the current team candidates.

10. The multi-agent cooperative construction method based on feature space orthogonality according to claim 5, characterized in that, The steps for outputting the orthogonalized intelligent agent team specifically include: after the team is formed, a decision priority matrix is ​​generated based on the relative capabilities of each member in different functional dimensions, and the dominance, assistance and sharing relationships of functional dimensions are transformed into runtime executable rules, so that the low-overlapping team structure can maintain the responsibility boundary in continuous operation, and provide verifiable and reviewable data for subsequent updates of functional vectors and evaluation of collaborative effects. Finally, the team members are written into the team relationship table.

Images