A remote sensing image processing system and method based on intelligent agent

Abstract

This invention belongs to the field of intelligent remote sensing image processing technology, and discloses a remote sensing image processing system and method based on intelligent agents. The system architecture includes an operator layer, an interaction layer, a data adaptation layer, and a dynamic process execution engine. The operator layer includes an operator registration module, a code generation module, and a test sandbox module. The interaction layer includes a natural language interaction module, a process automation generation module, and a visualization process module. The data adaptation layer includes a data interface specification module and a field adaptation middleware. Compared with traditional remote sensing image processing systems, this invention has strong operator scalability, simple data adaptation, and a low human-computer interaction threshold. It is particularly suitable for scenarios requiring rapid response to complex processing needs, such as satellite ground systems, emergency monitoring platforms, and environmental remote sensing monitoring, providing core technical support for building a new generation of intelligent remote sensing processing cloud platforms.

Description

Technical Field

[0001] This invention belongs to the field of intelligent remote sensing image processing technology, and specifically relates to a remote sensing image processing system and method based on intelligent agents. Background Technology

[0002] Traditional remote sensing image processing systems have long faced three major technical bottlenecks, severely restricting industry efficiency and emergency response capabilities. First, the reliance on fixed operator libraries for workflow construction, coupled with the need for manual compilation and deployment by professionals for algorithm expansion, results in new operator deployment cycles lasting several days. This static architecture cannot meet the demands of rapid algorithm iteration in scenarios such as disaster monitoring. For example, statistics from the China Resources Satellite Application Center show that 30% of processing time in emergency tasks is consumed in the operator adaptation phase. Second, significant differences in input and output formats exist between heterogeneous operators. The lack of unified standards for parameters such as band configuration, coordinate system, and resolution of different sensor data (e.g., multispectral and synthetic aperture radar SAR) leads to a processing interruption rate as high as 23%. Existing solutions rely on manually writing adaptation code, requiring an additional 1 to 2 hours for format conversion per task. Finally, there is a significant time lag between algorithm development cycles and task requirements. Traditional development models involve stages such as requirements analysis, code writing, testing, and deployment, making it difficult to address the real-time processing needs of emergencies such as forest fires.

[0003] The current wave of large language models and the rapid development of research related to intelligent agents offer new pathways to solving the aforementioned problems. Breakthroughs in natural language understanding using large models enable remote sensing image processing systems to accurately parse ambiguous natural language commands such as "extract flooded areas" and map them to specific algorithm combinations. The dynamic decision-making capabilities of intelligent agents, combined with reinforcement learning path planning, can improve operator matching accuracy to 92%. More importantly, code generation technology based on large models, combined with a sandbox testing environment, can automatically deploy new operators within 2 hours, a 90% speedup compared to traditional methods. Summary of the Invention

[0004] The purpose of this invention is to provide a remote sensing image processing system and method based on intelligent agents. Compared with traditional remote sensing image processing systems, this invention has strong operator scalability, simple data adaptation, and low human-computer interaction threshold. It is particularly suitable for scenarios that require rapid response to complex processing needs, such as satellite ground systems, emergency monitoring platforms, and environmental remote sensing monitoring. It provides core technical support for building a new generation of intelligent remote sensing processing cloud platforms.

[0005] The technical solution adopted in this invention is a remote sensing image processing system based on intelligent agents. The system architecture includes an operator layer, an interaction layer, a data adaptation layer, and a dynamic process execution engine. The operator layer includes an operator registration module, a code generation module, and a test sandbox module. The interaction layer includes a natural language interaction module, a process automation generation module, and a visualization process module. The data adaptation layer includes a data interface specification module and a field adaptation middleware.

[0006] The operator registration module is used to realize dynamic registration and intelligent retrieval of operator metadata; the code generation module generates operator code by integrating the Qwen3 model and pre-setting a remote sensing domain-specific template; the generated operator code is unit tested through the test sandbox module, and is saved after passing the test, and manually corrected and tested again if it fails; the test sandbox module performs code inspection and code execution inspection by building a basic verification system and a business verification system, and automatically completes the operator registration through a canary release mechanism after the inspection is completed;

[0007] The natural language interaction module uses a hybrid expert model to parse the natural language commands input by the user, converts them into structured parameters, integrates a confidence evaluation mechanism, scores the confidence of the parsing results, triggers multi-turn dialogue when the confidence level is below a threshold, and combines knowledge graphs to achieve semantic completion, thus completing an accurate understanding of the user's intent; the automated process generation module is used to realize task decomposition and process generation; the visualized process module is used to realize process DAG interaction and real-time process monitoring.

[0008] The data interface specification module is used to unify data interface specifications; the field adaptation middleware is used to realize automatic detection and mapping of input and output fields, dynamic format conversion and adaptation, and metadata repair.

[0009] The dynamic process execution engine allocates priorities based on the resource requirements and dependencies of operators, monitors the execution status of operators, and dynamically adjusts resource allocation. When an operator fails to execute in the process, the engine backtracks to the most recent checkpoint and calls the process automation generation module of the interaction layer to recommend an alternative operator to continue execution.

[0010] Furthermore, the operator registration module includes a dynamic operator metadata registration unit and an intelligent retrieval unit. The dynamic operator metadata registration unit supports dynamic loading and version management of operators, structures the operator metadata into JSON format, and vectorizes the structured operator metadata using the Jina-Embeddings-v3 model and stores it in a vector database. The intelligent retrieval unit is based on RAG technology, and inputs operator metadata, operator historical execution information, and resource consumption to achieve priority-based retrieval.

[0011] Furthermore, in the test sandbox module:

[0012] The basic verification system ensures that the operator code has no fundamental defects and meets the requirements for runtime stability through static code analysis, unit test coverage, and dynamic memory detection.

[0013] The business verification system conducts end-to-end testing by constructing a small remote sensing dataset to ensure that the operator's output results in real remote sensing tasks meet business logic and accuracy requirements.

[0014] The specific implementation process of the canary release mechanism is as follows:

[0015] The new operator first enters "shadow mode" and is executed in parallel with the existing operator, and the differences in results are compared.

[0016] When the difference exceeds the threshold, a manual correction process is triggered.

[0017] After the code is manually corrected, it undergoes testing through code inspection and code execution checks in a test sandbox. Once the tests pass, it is added to the workflow.

[0018] Furthermore, the natural language interaction module employs a hybrid expert model to parse the user's input natural language commands and convert them into structured parameters. The specific steps include:

[0019] Receive user natural language commands;

[0020] Semantic features are extracted using the BERT+BiLSTM model, and then the text is encoded.

[0021] Spatial context analysis is performed by combining current remote sensing image metadata to complete anomaly context correction and coordinate system constraints, including:

[0022] Abnormal context correction: If the user's natural language command conflicts with the current remote sensing image metadata context, a multi-turn dialogue is triggered to confirm the intent;

[0023] Coordinate system constraints: Convert vague expressions in user natural language commands into specific geographic coordinate ranges to avoid misunderstandings caused by coordinate system differences;

[0024] Output structured parameters.

[0025] Furthermore, the confidence assessment mechanism specifically includes:

[0026] (1) Semantic uncertainty quantification;

[0027] (2) Spatial context conflict detection;

[0028] (3) Knowledge graph semantic coverage verification;

[0029] (4) Dynamic threshold decision.

[0030] Furthermore, the automated process generation module includes a task decomposition unit and a process generation unit. The task decomposition unit, based on the thinking chain technology, decomposes composite tasks into atomic sub-task chains. After receiving the atomic sub-task chains, the process generation unit automatically matches operators by inputting system prompts, operator meta-information, and historical execution information of operators through a hybrid expert model. Then, it uses the ReAct framework combined with an improved A* algorithm path cost function to match the optimal operator and optimize the task execution path, setting the operator's configuration parameters and runtime resources to generate the optimal process. When no registered operator is found in the operator library, a code generation sandbox is triggered for verification. After verification, the newly generated operator is registered in the operator library and added to the process. Finally, a loop termination condition is designed to prevent infinite reasoning. The visualized process module includes a process DAG interaction unit and a process real-time monitoring unit. The process DAG interaction unit allows users to adjust the operator order and operator configuration parameters and modify the processing flow by dragging and dropping and using forms. The process real-time monitoring unit supports real-time performance monitoring and marks abnormal nodes.

[0031] Furthermore, the task decomposition unit, based on the thinking chain technology, decomposes a composite task into a chain of atomic sub-tasks using the following specific steps:

[0032] Receive the converted structured parameters;

[0033] Search for historical similar process task cases using search enhancement generation technology;

[0034] Structured parameters, historical similar process task cases, and current remote sensing image metadata are used to construct system prompt words. Based on the thinking chain technology, task execution paths are constructed, and composite tasks are decomposed into atomic sub-task chains.

[0035] Output the atomic task chain.

[0036] Furthermore, the field adaptation middleware includes an automatic detection and mapping unit for input and output fields, a dynamic format conversion and adaptation unit, and a metadata repair unit. The automatic detection and mapping unit for input and output fields detects differences in the names, data types, dimensions, spatial references, and metadata tags of input and output fields between operators in real time; it understands the semantics of fields through a rule engine or large model and automatically associates synonymous fields; when the dynamic format conversion and adaptation unit detects inconsistencies in data types between the inputs and outputs of adjacent operators, it automatically inserts forced type conversion logic, band order adjustment, and coordinate system conversion operators; it resolves multidimensional data conflicts through structural adaptation or unifies resolution through interpolation / resampling; when the operator output loses key metadata, the metadata repair unit inherits and supplements it from upstream data or global configuration, and automatically adds semantic tags to unlabeled data.

[0037] A remote sensing image processing method based on intelligent agents, implemented according to the aforementioned remote sensing image processing system based on intelligent agents, includes the following steps:

[0038] S1, at the operator layer, the prepared operators are registered through the operator registration module, and the operator metadata is stored in a vectorized form.

[0039] S2, where the user inputs natural language commands at the interaction layer;

[0040] S3, the natural language interaction module of the interaction layer uses a hybrid expert model to parse the natural language instructions input by the user and convert them into structured parameters. If the confidence level is lower than the threshold, it triggers multi-turn dialogue and semantic completion to achieve accurate understanding of the user's intent.

[0041] S4, the process automation generation module of the interaction layer, after receiving the structured parameters converted by the natural language interaction module, decomposes the composite task into a chain of atomic sub-tasks based on the thinking chain technology.

[0042] S5, the process automation generation module of the interaction layer automatically matches operators by inputting system prompts, operator meta-information and historical execution information of operators through a hybrid expert model. Then, it matches the optimal operator and optimizes the task execution path by combining the ReAct framework with the improved A* algorithm path cost function. Then, it completes the modification and confirmation of the field configuration information of the process through the field adaptation middleware of the data adaptation layer, and finally outputs the process description file.

[0043] S6. When no operator is found in the operator library, the code generation sandbox is triggered and verified. After verification, the newly generated operator is registered in the operator library and added to the process.

[0044] S7, after receiving the generated process, the visualization process module of the interaction layer displays it on the user interface through a directed acyclic graph (DAG), allowing users to modify the operator order and operator configuration parameters in the process by dragging and dropping and using forms.

[0045] S8, the dynamic process execution engine, monitors the execution status of operators based on their resource requirements, dependencies, and the current system resource allocation and operator scheduling priority, dynamically adjusting resource allocation to achieve DAG task scheduling. It automatically saves the intermediate state to the distributed cache Redis every time three atomic subtasks are completed or the execution time reaches 120 seconds. If an operator fails during process execution, the engine backtracks to the most recent checkpoint, calls the process automation generation module to recommend an alternative operator to continue execution, and simultaneously records failure logs and updates historical performance metrics.

[0046] Furthermore, in S5, after receiving the atomic sub-task chain, the automated process generation module of the interaction layer automatically matches operators by inputting system prompts, operator meta-information, and historical execution information of operators through a hybrid expert model. Then, it uses the ReAct framework combined with the improved A* algorithm path cost function to match the optimal operator and optimize the task completion path. The specific steps include:

[0047] S51: Construct the initial decision-making environment, receive the atomic subtask chain, and dynamically load the environment context;

[0048] Dynamically loaded environment contexts include:

[0049] (1) Real-time status of the operator library;

[0050] (2) System-level constraints;

[0051] (3) Data characteristics;

[0052] S52, the ReAct framework's closed-loop decision-making process, cyclically executes the following four stages until operator matching for all atomic subtasks is completed:

[0053] The first stage is the reasoning stage: Based on the current atomic subtask and environmental context, a decision-making chain is generated, and structured decision options are output. When no operator is matched in the operator library, the code generation sandbox is triggered and verified. After verification, the newly generated operator is registered to the operator library and added to the process.

[0054] The second phase is the action phase: This involves invoking the improved A* algorithm path cost function to match the optimal operator and optimize the task execution path. Specific steps include:

[0055] (1) Based on the dynamic topology reconstruction mechanism, analyze the data dependency relationship between atomic subtasks, reconstruct the DAG topology structure of the directed acyclic graph by splitting and merging branches, split the atomic subtasks without data coupling into independent execution flows, and realize multi-operator parallel computing;

[0056] (2) Path cost optimization;

[0057] The path cost function based on the improved A* algorithm is:

[0058]

[0059]

[0060] Where Cost is the path cost of the operator; F represents the historical average time taken by the operator. rate R represents the historical failure rate of the operator. comp This represents the real-time resource contention coefficient. Weighted by time cost; For failure penalty weights; k, m, n are coefficients that can be set; GPU util For GPU utilization; CPU util For CPU utilization; mem util For memory utilization;

[0061] (3) Path search process;

[0062] Construct a directed acyclic graph (DAG) with atomic subtasks as nodes, initialize an open list, iteratively expand the path, and select the node with the smallest cost function f(n) at each step;

[0063]

[0064] Where f(n) is the total cost of executing the current node and completing the task; g(n) is the actual cost from the starting point to the current node; and h(n) is the estimated cost of the remaining subtasks.

[0065] When a resource conflict is detected, an adaptive resource scheduling strategy is implemented to dynamically adjust the real-time resource contention coefficient R. comp And reorder;

[0066] (4) Operator matching;

[0067] For each operator subtask, select the operator with the minimum path cost from the operator candidate pool;

[0068] The third stage is the observation stage: verifying the operator matching constraints and generating an anomaly report when a conflict is detected;

[0069] The fourth stage is the feedback and adjustment stage: dynamic adaptation is triggered based on the conflict type, and it is carried out from the following four aspects:

[0070] Insert a degradation operator when resource conflicts occur;

[0071] Insert a format conversion operator when data is incompatible;

[0072] Insert an automatic transpose operator when data bit depths are incompatible;

[0073] For other non-predefined conflict types, add the conflict report to the environment context and return to the first phase.

[0074] Furthermore, the specific steps of S6 include:

[0075] S61, build code to generate prompts;

[0076] S62, input the code generation prompts into the Qwen3 large model to complete the code writing, and perform code inspection and code execution inspection after the code writing is completed;

[0077] S63: After the check is completed, the operator is automatically registered through the canary release mechanism and added to the process; if the check fails, the code is manually corrected, and the check is repeated after the modification is confirmed.

[0078] Furthermore, in S8, the priority calculation for operator scheduling adopts a three-level priority calculation model, and the priority weight formula is as follows:

[0079]

[0080] Where Priority is the scheduling priority of the operator in this task flow; DepPriority is the dependency priority; ResPriority is the resource priority; and DynamicAdj is the dynamic adjustment factor.

[0081] The beneficial effects of this invention are as follows:

[0082] Compared with traditional remote sensing image processing systems, this invention has strong operator scalability, simple data adaptation, and low human-computer interaction threshold. It is particularly suitable for scenarios that require rapid response to complex processing needs, such as satellite ground systems, emergency monitoring platforms, and environmental remote sensing monitoring, providing core technical support for building a new generation of intelligent remote sensing processing cloud platforms. Attached Figure Description

[0083] Figure 1 This is a schematic diagram of the data interaction of the system of the present invention.

[0084] Figure 2 This is a flowchart illustrating the method of the present invention. Detailed Implementation

[0085] To make the objectives, technical solutions, and advantages of this invention clearer and more understandable, the technical solutions of this invention will be further described in detail below with reference to the accompanying drawings.

[0086] Intelligent agents are an important concept in the fields of computer science and artificial intelligence in recent years. They refer to computing entities that reside in a specific environment, can perceive the environment, and can operate autonomously to achieve a series of goals on behalf of their designers or users.

[0087] A remote sensing image processing system based on intelligent agents is described below. The system architecture includes an interaction layer, a dynamic process execution engine, an operator layer, and a data adaptation layer. Figure 1 The present invention provides a detailed description of the remote sensing image processing system based on intelligent agents:

[0088] I. Operator Layer

[0089] The operator layer includes an operator registration module, a code generation module, and a test sandbox module.

[0090] 1. Operator Registration Module

[0091] The operator registration module is used to realize the dynamic registration and intelligent retrieval of operator metadata.

[0092] The operator registration module includes a dynamic registration unit for operator metadata and an intelligent retrieval unit.

[0093] (1) Dynamic registration unit for operator element information

[0094] It supports dynamic loading and version management of operators, structures operator metadata into JSON format, and vectorizes the structured operator metadata using the Jina-Embeddings-v3 model and stores it in a vector database.

[0095] Operator metadata includes input / output data types, configuration parameter templates, resource requirements (such as CPU / GPU quotas and memory limits), and dependencies (third-party library versions).

[0096] (2) Intelligent retrieval unit

[0097] Based on RAG technology, priority sorting retrieval is achieved by inputting operator metadata, operator historical execution information, and resource consumption data.

[0098] 2. Code generation module

[0099] Operator code is generated by integrating the Qwen3 model and pre-setting specific templates for the remote sensing field (such as GDAL data read / write interface, SNAP operator adaptation, coordinate transformation, depth transformation and band recombination, etc.). The generated operator code is unit tested through the test sandbox module. If the test passes, it is saved. If it fails, it is manually corrected and then tested again.

[0100] 3. Test Sandbox Module

[0101] Code inspection and code execution inspection are carried out by building a basic verification system and a business verification system. After the inspection is completed, the operator registration is automatically completed through a canary release mechanism.

[0102] The basic verification system is mainly to ensure that the operator code has no fundamental defects and meets the requirements for operational stability.

[0103] The basic verification system includes static code analysis, unit test coverage, and dynamic memory detection.

[0104] Static code analysis uses the SonarQube+Pylint code inspection tool to detect syntax errors, security vulnerabilities, code style issues, and third-party dependency conflicts.

[0105] Unit test coverage tests the code by generating different test cases at the method level (such as boundary tests, normal tests, exception tests, etc.).

[0106] Dynamic memory detection monitors memory leak thresholds (e.g., memory growth ≤2% after 10 consecutive runs) by injecting abnormal data (e.g., null pointers, excessively large matrices).

[0107] The specific steps for building a basic verification system include:

[0108] The MCP Server program integrates the SonarQube+Pylint code inspection tool to perform static analysis on automatically generated operator code.

[0109] The entire operator code is tested by generating different test cases at the function and class levels based on the operator code.

[0110] Build Docker containers that run operators independently, inject abnormal data into the operators, and monitor the memory leak threshold of the containers.

[0111] The business verification system conducts end-to-end testing by constructing small remote sensing datasets (such as Landsat-8 sub-regions) to ensure that the operator's output results in real remote sensing tasks meet business logic and accuracy requirements.

[0112] The specific steps for building a business verification system include:

[0113] Construct small test datasets for different types of operators. The test datasets include data, accuracy metrics, and timeliness metrics.

[0114] Build a standalone Docker container for the operator, inject the test dataset, run the operator, and record the operator's running results and time-sensitive results.

[0115] Result verification: The results of the operator's operation are compared with the true values ​​in the test dataset. If the comparison results meet the threshold, the timeliness and resource constraints are checked based on the timeliness results of the operator's operation.

[0116] The specific implementation process of the canary release mechanism is as follows:

[0117] The new operator first enters "shadow mode" and is executed in parallel with the existing operator to compare the differences in results.

[0118] When the difference exceeds a threshold (e.g., Intersection over Union (IOU) < 0.9), a manual correction process is triggered.

[0119] After the code is manually corrected, it undergoes testing through code inspection and code execution checks in a test sandbox. Once the tests pass, it is added to the workflow.

[0120] II. Interaction Layer

[0121] The interaction layer includes a natural language interaction module, a process automation generation module, and a visual process module.

[0122] 1. Natural Language Interaction Module

[0123] A hybrid expert model is used to parse user-input natural language commands (e.g., "extract flooded areas"), converting them into structured parameters ({algorithm type: water body detection, band requirement: SWIR}). An integrated confidence assessment mechanism is used to score the parsing results (0-1). If the score is below a threshold, a multi-turn dialogue is triggered (e.g., do you mean vegetation cover or water body extraction?). Semantic completion is achieved by combining knowledge graphs [e.g., mapping ambiguous natural language commands ("extract water bodies") into structured parameters (band = SWIR / NIR, algorithm = NDWI / MNDWI)], thus achieving a precise understanding of the user's intent.

[0124] The natural language interaction module uses a hybrid expert model to parse user-input natural language commands and convert them into structured parameters. The specific steps include:

[0125] Receive user commands in natural language.

[0126] Semantic features are extracted using the BERT+BiLSTM model for text encoding.

[0127] Spatial context analysis is performed by combining current remote sensing image metadata, mainly to complete anomaly context correction and coordinate system constraints, including:

[0128] Abnormal context correction: If the user's natural language command conflicts with the current remote sensing image metadata context (e.g., requesting "extract snow" but the image was taken in summer and is located in a tropical region), trigger a multi-turn dialogue to confirm the intent;

[0129] Coordinate system constraints: Convert vague expressions in user natural language commands (such as "southwest region") into specific geographic coordinate ranges to avoid misunderstandings caused by coordinate system differences.

[0130] Output structured parameters.

[0131] The confidence assessment mechanism specifically includes:

[0132] (1) Semantic uncertainty quantification

[0133] The initial confidence score is calculated using a BERT-BiLSTM dual-channel semantic coding architecture. The BERT layer extracts the global semantic features of the user command (e.g., mapping "extract flood" to "extract water body"), while the BiLSTM layer captures local contextual dependencies (e.g., identifying the spatial orientation attribute of "southwest"). Calculated using the inverse proportion of information entropy:

[0134] Formula 1

[0135] Wherein, Entropy is the information entropy function, used to quantify the uncertainty of the probability distribution; P(y) is the intent classification probability distribution of the dual-channel semantic encoding output.

[0136] A higher entropy value indicates greater semantic uncertainty and lower basic confidence.

[0137] Formula 2

[0138] Where n is the total number of intent categories; This represents the predicted probability of the i-th type of intention.

[0139] (2) Spatial context conflict detection

[0140] Logical conflict determination is performed based on a pre-built remote sensing domain rule base, which contains over 300 professional constraints (e.g., "Summer + Snow Extraction = High Conflict Probability"). Conflict probabilities are categorized as extremely high (0.8), high (0.7), medium (0.5), low (0.2), extremely low (0.1), and no conflict (0). The system loads current remote sensing image metadata (including geographic region, season, sensor type, etc.) in real time and performs conflict scanning through the rule engine.

[0141] The initial confidence level correction is implemented using a product decay model:

[0142] Formula 3

[0143] Among them, Conf adj The initial confidence score is the corrected value; conflict_score is the conflict probability. For example, if a conflict value of 0.2 is detected, the original confidence score of 0.86 will be corrected to 0.688.

[0144] (3) Validation of semantic coverage of knowledge graph

[0145] Construct a domain knowledge graph to achieve standardized terminology mapping. Graph nodes include remote sensing entities (such as sensors, bands, and algorithms), data products, and processing flows.

[0146] Coverage calculation is implemented using an entity matching rate model:

[0147] Formula 4

[0148] For example, the instruction "use SWIR and NIR for water body extraction" contains the entities [SWIR, NIR, water body extraction]. The knowledge graph matching results are SWIR → shortwave infrared (match), NIR → near-infrared (match), and water body extraction → NDWI (match). Therefore, Coverage = 1.0.

[0149] Confidence after coverage compensation final The corrected formula is:

[0150] Formula 5

[0151] The confidence level after the previous correction was 0.688, which was increased to 0.888 after coverage compensation.

[0152] (4) Dynamic threshold decision

[0153] Set up a scene-adaptive confidence threshold system: the threshold for directly outputting structured parameters is 0.7 (can be set manually), and if it is lower than 0.7, multi-turn dialogue will be triggered directly.

[0154] 2. Automated Process Generation Module

[0155] Used to implement task decomposition and process generation.

[0156] The automated process generation module includes a task decomposition unit and a process generation unit.

[0157] (1) Task decomposition unit

[0158] Based on the thinking chain technology, complex tasks are decomposed into atomic sub-task chains (for example, "flood assessment" is decomposed into: sub_tasks=["radiation correction", "water index calculation", "change detection", "inundation range statistics"]). The specific steps include:

[0159] Receives converted structured parameters.

[0160] Search-enhanced generation techniques are used to retrieve historical similar process task cases.

[0161] Structured parameters, historical similar process task cases, and current remote sensing image metadata are used to construct system prompt words. Based on the thinking chain technology, task execution paths are constructed, and composite tasks are decomposed into atomic sub-task chains.

[0162] Output the atomic task chain.

[0163] (2) Process generation unit

[0164] Upon receiving the atomic sub-task chain, the system automatically matches operators by inputting system prompts, operator metadata, and historical execution information of the operators through a hybrid expert model. Then, the ReAct framework, combined with an improved A* algorithm path cost function, matches the optimal operator and optimizes the task execution path. The configuration parameters and runtime resources of the operators are set to generate the optimal process. When no registered operator is found in the operator library, a code generation sandbox is triggered for verification. After verification, the newly generated operator is registered in the operator library and added to the process. Finally, a loop termination condition (maximum number of iterations = 5) is designed to prevent infinite reasoning.

[0165] 3. Visualized Process Module

[0166] Used to implement process DAG (Directed Acyclic Graph) interaction and real-time process monitoring.

[0167] The visualization process module includes a process DAG interaction unit and a process real-time monitoring unit.

[0168] (1) Process DAG interaction unit

[0169] Allows users to adjust the operator order and operator configuration parameters, and modify the processing flow by dragging and dropping or using forms.

[0170] (2) Real-time process monitoring unit

[0171] It supports real-time performance monitoring (such as monitoring node time consumption and resource utilization) and marks abnormal nodes (such as operator failures).

[0172] III. Data Adaptation Layer

[0173] The data adaptation layer includes a data interface specification module and field adaptation middleware.

[0174] 1. Data Interface Specification Module

[0175] This is used to unify data interface specifications, specifically including coordinate system (EPSG code), resolution, band order (BGR / RGB), and data type (uint16 / float32 type), etc.

[0176] 2. Field adaptation middleware

[0177] It is used to achieve automatic detection and mapping of input and output fields, dynamic format conversion and adaptation, and metadata repair.

[0178] The field adaptation middleware includes an automatic detection and mapping unit for input and output fields, a dynamic format conversion and adaptation unit, and a metadata repair unit.

[0179] (1) Automatic detection and mapping unit for input and output fields

[0180] Real-time detection of differences in the names, data types, dimensions, spatial references, and metadata tags of input and output fields between operators (e.g., operator A outputs a field named "NDVI", while operator B requires an input field named "vegetation index"); understanding field semantics through a rule engine or large model, and automatically associating synonymous fields (e.g., "SWIR" band and "shortwave infrared" band).

[0181] Large Model Understanding Field Semantics: Leveraging Large Language Models (LLM) to parse the deep meaning of remote sensing data fields and bridge the semantic gap between heterogeneous operators. The core objective is to map fields from different sources and with different names (such as "NDVI" and "vegetation index") to a unified semantic space, enabling intelligent field association and adaptation, and overcoming the limitations of traditional rule engines.

[0182] (2) Dynamic format conversion and adaptation unit

[0183] When a data type inconsistency is detected between the input and output of adjacent operators, the system automatically inserts operators forcibly converting types (e.g., float32 to uint16), adjusting band order (e.g., BGR to RGB), and transforming coordinate systems (e.g., WGS84 to UTM). It resolves multidimensional data conflicts through structural adaptation (e.g., splitting a 3-band RGB color image into a single-band input) or unifies the resolution through interpolation / resampling (e.g., 10m → 5m).

[0184] (3) Metadata Repair Unit

[0185] In cases where key metadata (such as coordinate systems) is missing from the operator output, it is inherited and supplemented from upstream data or global configuration (such as the EPSG code associated with the original image), and semantic labels are automatically added to unlabeled data (such as renaming "Band_1" to "NIR" band).

[0186] IV. Dynamic Flow Execution Engine

[0187] Prioritize operators based on their resource requirements and dependencies, monitor their execution status, and dynamically adjust resource allocation to achieve DAG task scheduling. If an operator fails to execute in the process (e.g., due to insufficient memory), the engine backtracks to the most recent checkpoint and calls the process automation generation module to recommend an alternative operator (e.g., replacing "DeepLabV3+" with "Lightweight Mobile-UNet") to continue execution.

[0188] A remote sensing image processing method based on intelligent agents is implemented through the aforementioned remote sensing image processing system based on intelligent agents, such as... Figure 2 As shown, the specific steps include:

[0189] S1, at the operator layer, the prepared operators are registered through the operator registration module, and the operator metadata is stored in a vectorized form.

[0190] Operator files include Python executable code files and operator configuration files.

[0191] The operator configuration file defines the operator's type, input, output, required resources, configuration parameters, and description information.

[0192] S2, where the user inputs natural language commands in the interaction layer.

[0193] S3, the natural language interaction module of the interaction layer uses a hybrid expert model to parse the natural language instructions input by the user and convert them into structured parameters. If the confidence level is lower than the threshold, it triggers multi-turn dialogue and semantic completion to achieve accurate understanding of the user's intention.

[0194] S4, the process automation generation module of the interaction layer, after receiving the structured parameters converted by the natural language interaction module, decomposes the composite task into a chain of atomic sub-tasks based on the thinking chain technology.

[0195] S5, the process automation generation module of the interaction layer automatically matches operators by inputting system prompts, operator metadata, and historical execution information of operators (such as the number of successful executions, the number of failed executions, the reasons for failures, and the execution time) through a hybrid expert model. Then, it uses the ReAct framework combined with the improved A* algorithm path cost function to match the optimal operator and optimize the task execution path. Next, it uses the field adaptation middleware of the data adaptation layer to complete the modification and confirmation of the process field configuration information. Finally, it outputs a process description file [the process description file is in JSON format and includes operator binding sequences, operator parameter configurations, operator resource allocation schemes (such as GPU, memory, CPU quotas, and checkpoint intervals), and operator exception handling records (such as a list of backup operators)].

[0196] After receiving the atomic sub-task chain, the automated process generation module of the interaction layer automatically matches operators by inputting system prompts, operator meta-information, and historical execution information of operators through a hybrid expert model. Then, it uses the ReAct framework combined with the improved A* algorithm path cost function to match the optimal operator and optimize the task completion path. The specific steps include:

[0197] S51, construct the initial decision environment, receive the atomic sub-task chain (e.g., ["radiation correction", "water index calculation"]), and dynamically load the environment context;

[0198] Dynamically loaded environment contexts include:

[0199] (1) Real-time status of the operator library [including operator availability, resource usage, operator historical execution logs and operator metadata; the operator metadata structure is JSON data, including input / output specifications (e.g., data type, band order, spatial reference), resource requirements (e.g., GPU memory > 4GB), algorithm dependencies (e.g., TensorFlow 2.15 version), historical performance indicators (e.g., success rate of 92.3%, average execution time of 23s); the operator historical execution log is dynamically updated runtime data, using a sliding window to record the most recent 100 execution records, including actual resource usage (e.g., CPU peak of 85%), abnormal modes (e.g., memory leak probability of 0.7%) and contextual relevance (e.g., 89% compatibility with NDWI algorithm)].

[0200] (2) System-level constraints (maximum delay ≤ 300 seconds, accuracy threshold ≥ 0.9).

[0201] (3) Data characteristics (upstream input data type, auxiliary data information, spatial reference system, output data type).

[0202] S52, the ReAct framework's closed-loop decision-making process, cyclically executes the following four stages until operator matching for all atomic subtasks is completed:

[0203] The first stage is the reasoning stage: Based on the current atomic subtask and environmental context, a decision-making chain is generated, and structured decision options are output ({action type: operator selection, candidate operators: ["NDWI_V2.1", "NDWI_Lite"]}). When no operator is matched in the operator library, the code generation sandbox is triggered and verified. After verification, the newly generated operator is registered to the operator library and added to the process.

[0204] The second phase is the action phase: This involves invoking the improved A* algorithm path cost function to match the optimal operator and optimize the task execution path. Specific steps include:

[0205] (1) Based on the dynamic topology reconstruction mechanism, analyze the data dependency relationship between atomic subtasks, reconstruct the DAG topology structure by splitting and merging branches, split the atomic subtasks without data coupling into independent execution flows, and realize multi-operator parallel computing.

[0206] (2) Path cost optimization;

[0207] The path cost function based on the improved A* algorithm is:

[0208] Formula 6

[0209] Formula 7

[0210] Where Cost is the path cost of the operator; F represents the historical average execution time (in seconds) of the operator. rate R represents the historical failure rate of the operator (0~1). comp This represents the real-time resource contention coefficient. Time cost weight (initial value 1.0, value 1.5 when GPU / CPU utilization exceeds 80%). This is the failure penalty weight (default value is 2.0, configurable); k, m, and n are coefficients, which can be set. The initial values ​​are k=0.8, m=0.5, and n=0.7. For CPU operators, k=0, m=0.7, and n=0.8; GPU util For GPU utilization; CPU util For CPU utilization; mem util This refers to memory utilization.

[0211] (3) Path search process;

[0212] Construct a directed acyclic graph (DAG) with atomic subtasks as nodes, initialize an open list, iteratively expand the path, and select the node with the smallest cost function f(n) at each step.

[0213] Formula 8

[0214] Where f(n) is the total cost of executing the current node and completing the task; g(n) is the actual cost from the starting point to the current node; and h(n) is the estimated cost of the remaining subtasks (i.e., the cost from the current node to the end node).

[0215] When resource conflicts are detected (e.g., GPU, CPU, or memory utilization exceeds 80%), an adaptive resource scheduling strategy is implemented to dynamically adjust the real-time resource contention coefficient R. comp And reorder them.

[0216] (4) Operator matching;

[0217] For each operator subtask, select the operator with the minimum path cost (Cost) from the operator candidate pool.

[0218] Dynamic topology reconstruction mechanism: When the cumulative path cost function value exceeds the preset threshold, the data dependency relationship between atomic subtasks is analyzed, and the DAG topology structure is reconstructed by splitting and merging branches. The atomic subtasks without data coupling are split into independent execution flows to achieve parallel computing of multiple operators.

[0219] Adaptive resource scheduling strategy: Real-time resource contention coefficient R compBased on the cluster's real-time load dynamic refresh (refresh cycle ≤ 5 seconds), when GPU / CPU / memory utilization is detected to be greater than or equal to 80% for 30 consecutive seconds, the real-time resource contention coefficient R is automatically increased. comp The value is increased to 1.5 times the baseline value, and the operator degradation strategy is triggered (the GPU operator is replaced with the CPU operator).

[0220] The third stage is the observation stage: verifying the operator matching constraints [including data compatibility (upstream input data type, auxiliary data information, spatial reference system, output data type), resource feasibility (GPU, memory, number of CPU cores) and algorithm dependency satisfaction (third-party library version)]. When a conflict is detected, an exception report is generated (e.g., {Conflict type: insufficient resources, operator: NDWI_V2.1, required GPU: 4GB, available GPU: 3.2GB}).

[0221] The fourth stage is the feedback and adjustment stage: dynamic adaptation is triggered based on the type of conflict, mainly in the following four aspects:

[0222] When resource conflicts occur, a degradation operator is inserted (when the GPU cannot meet the requirements, the CPU is used for calculation).

[0223] Insert format conversion operators (TIFF to JPEG / TIFF to PNG format) when data is incompatible.

[0224] When data bit depths are incompatible, insert an automatic transpose operator (float32 to UINT16 type).

[0225] For other non-predefined conflict types, add the conflict report to the environment context and return to the first phase.

[0226] S6: When no operator is found in the operator library, a code generation sandbox is triggered for verification. After verification, the newly generated operator is registered in the operator library and added to the process. The specific steps include:

[0227] S61, Build code generation prompt (e.g.: You are an expert in radiometric correction in the field of remote sensing. The input data is: *.tif, the data metadata is: {number of bands: 3, bit depth: 8, band order: BGR}, the resource requirements are: {CPU: 4, memory: 500MB}, the language requirement is: python. Please write an operator to complete the radiometric correction of this data).

[0228] S62: Input the code generation prompts into the Qwen3 large model to complete the code writing. After the code is written, perform code inspection and code execution inspection.

[0229] S63: After the check is completed, the operator registration is automatically completed through the gray release mechanism; if the check fails, the code is manually corrected, and the check is repeated after the modification is confirmed.

[0230] S7, after receiving the generated process, the visualization process module of the interaction layer displays it on the user interface through a directed acyclic graph (DAG). Users can modify the operator order and operator configuration parameters in the process by dragging and dropping and using forms.

[0231] S8, the dynamic process execution engine, monitors the execution status of operators based on their resource requirements, dependencies, and the current system resource allocation and operator scheduling priority. It dynamically adjusts resource allocation to achieve DAG task scheduling. Every time three atomic subtasks are completed or the execution time reaches 120 seconds, the engine automatically saves the intermediate state (the state between the start and end of the entire process execution, the execution status of a certain operator or a combination of operators (execution successful, execution failed, executing, etc.)) to the distributed cache Redis. If an operator fails during process execution (e.g., due to insufficient memory), the engine backtracks to the most recent checkpoint, calls the process automation generation module to recommend an alternative operator to continue execution, and records the failure log to update historical performance metrics.

[0232] Since the process only specifies the execution order of operators in the current process, when multiple processes are issued at the same time, it is necessary to calculate the scheduling priority of operators based on the current resource status of the system. Once the scheduling priority of the operators is determined, the operators are directly scheduled to the corresponding nodes for execution.

[0233] The operator scheduling priority calculation adopts a three-level priority calculation model, and the priority weight formula is as follows:

[0234] Formula 9

[0235] Where Priority is the scheduling priority of the operator in this task flow; DepPriority is the dependency priority, which is divided into head node, independent node (predecessor node has been completed), and ordinary node (predecessor node has not been completed) according to the node type in the directed acyclic graph (DAG). The DepPriority value of the head node is 1.0, the DepPriority value of the independent node is 0.8, and the DepPriority value of the ordinary node is 0.5.

[0236] ResPriority is the resource priority, calculated using the following formula:

[0237] Formula 10

[0238] Where ReqResource is the normalized resource value requested by the operator (weighted sum of GPU memory + CPU core count + Mem); ClusterMax is the weighted sum of the maximum resource capacity of a single node in the system;

[0239] DynamicAdj is a dynamic adjustment factor with an initial value of 0; its value is 0.1 when the cluster's idle resources (memory / CPU / GPU utilization) are greater than 50%; and its value is 0.3 when the task is urgent.

[0240] Dynamic resource allocation adjustment refers to the system reclaiming allocated resources after a certain operator finishes execution, recalculating the scheduling priority of subsequent operators in the directed acyclic graph (DAG), and allocating and executing resources according to their scheduling priorities.

[0241] This invention integrates the concept and technology of intelligent agents (AI Agents) into the intelligent processing of remote sensing data, evolving from the traditional "data input" - "fixed algorithm processing" - "result output" model to a higher-level intelligent system characterized by "goal-driven, autonomous perception, intelligent decision-making, collaborative execution, continuous learning, and closed-loop feedback". It provides a powerful technical framework and implementation path for building an automated, intelligent, adaptive, and collaborative next-generation remote sensing information processing platform.

[0242] Any content not described in detail in this specification belongs to the prior art in this technical field.

Claims

1. A remote sensing image processing system based on intelligent agents, characterized in that, The system architecture includes an operator layer, an interaction layer, a data adaptation layer, and a dynamic process execution engine; the operator layer includes an operator registration module, a code generation module, and a test sandbox module; the interaction layer includes a natural language interaction module, a process automation generation module, and a visualization process module; the data adaptation layer includes a data interface specification module and a field adaptation middleware. The operator registration module is used to realize dynamic registration and intelligent retrieval of operator metadata; the code generation module generates operator code by integrating the Qwen3 model and pre-setting a remote sensing domain-specific template; the generated operator code is unit tested through the test sandbox module, and is saved after passing the test, and manually corrected and tested again if it fails; the test sandbox module performs code inspection and code execution inspection by building a basic verification system and a business verification system, and automatically completes the operator registration through a canary release mechanism after the inspection is completed; The natural language interaction module uses a hybrid expert model to parse the natural language commands input by the user, converts them into structured parameters, integrates a confidence evaluation mechanism, scores the confidence of the parsing results, triggers multi-turn dialogue when the confidence level is below a threshold, and combines knowledge graphs to achieve semantic completion, thus completing an accurate understanding of the user's intent; the automated process generation module is used to realize task decomposition and process generation; the visualized process module is used to realize process DAG interaction and real-time process monitoring. The data interface specification module is used to unify data interface specifications; The field adaptation middleware is used to realize automatic detection and mapping of input and output fields, dynamic format conversion and adaptation, and metadata repair. The dynamic process execution engine allocates priorities based on the resource requirements and dependencies of operators, monitors the execution status of operators, and dynamically adjusts resource allocation. When an operator fails to execute in the process, the engine backtracks to the most recent checkpoint and calls the process automation generation module in the interaction layer to recommend an alternative operator to continue execution.

2. The remote sensing image processing system based on intelligent agents according to claim 1, characterized in that, The operator registration module includes an operator meta-information dynamic registration unit and an intelligent retrieval unit; the operator meta-information dynamic registration unit supports dynamic loading and version management of operators, structures the operator meta-information into JSON format, and vectorizes the structured operator meta-information through the Jina-Embeddings-v3 model and stores it in a vector database. The intelligent retrieval unit is based on RAG technology. It takes operator metadata, operator historical execution information and resource consumption as input to achieve priority sorting retrieval.

3. The remote sensing image processing system based on intelligent agents according to claim 1, characterized in that, In the test sandbox module: The basic verification system ensures that the operator code has no fundamental defects and meets the requirements for runtime stability through static code analysis, unit test coverage, and dynamic memory detection. The business verification system conducts end-to-end testing by constructing a small remote sensing dataset to ensure that the operator's output results in real remote sensing tasks meet business logic and accuracy requirements. The specific implementation process of the canary release mechanism is as follows: The new operator first enters "shadow mode" and is executed in parallel with the existing operators, and the differences in results are compared. When the difference exceeds the threshold, a manual correction process is triggered. After the code is manually corrected, it undergoes testing through code inspection and code execution checks in a test sandbox. Once the tests pass, it is added to the workflow.

4. The remote sensing image processing system based on intelligent agents according to claim 1, characterized in that, The natural language interaction module uses a hybrid expert model to parse the user's input natural language commands and convert them into structured parameters. The specific steps include: Receive user natural language commands; Semantic features are extracted using the BERT+BiLSTM model, and then the text is encoded. Spatial context analysis is performed by combining current remote sensing image metadata to complete anomaly context correction and coordinate system constraints, including: Abnormal context correction: If the user's natural language command conflicts with the current remote sensing image metadata context, a multi-turn dialogue is triggered to confirm the intent; Coordinate system constraints: Convert vague expressions in user natural language commands into specific geographic coordinate ranges to avoid misunderstandings caused by coordinate system differences; Output structured parameters.

5. The remote sensing image processing system based on intelligent agents according to claim 1, characterized in that, The confidence assessment mechanism specifically includes: (1) Semantic uncertainty quantification; (2) Spatial context conflict detection; (3) Knowledge graph semantic coverage verification; (4) Dynamic threshold decision.

6. The remote sensing image processing system based on intelligent agents according to claim 1, characterized in that, The automated process generation module includes a task decomposition unit and a process generation unit. The task decomposition unit, based on the thinking chain technology, decomposes composite tasks into atomic sub-task chains. After receiving the atomic sub-task chains, the process generation unit automatically matches operators by inputting system prompts, operator meta-information, and historical execution information of operators through a hybrid expert model. Then, it uses the ReAct framework combined with an improved A* algorithm path cost function to match the optimal operator and optimize the task execution path, sets the configuration parameters and runtime resources of the operators, and generates the optimal process. When no registered operator is found in the operator library, a code generation sandbox is triggered for verification. After verification, the newly generated operator is registered in the operator library and added to the process. Finally, a loop termination condition is designed to prevent infinite reasoning. The visualization process module includes a process DAG interaction unit and a process real-time monitoring unit; the process DAG interaction unit allows users to adjust the operator order and operator configuration parameters and modify the processing flow by dragging and dropping and using forms. The process real-time monitoring unit supports real-time performance monitoring and identifies abnormal nodes.

7. The remote sensing image processing system based on intelligent agents according to claim 6, characterized in that, The task decomposition unit, based on the thinking chain technology, decomposes a composite task into a chain of atomic sub-tasks. The specific steps include: Receive the converted structured parameters; Search for historical similar process task cases using search enhancement generation technology; Structured parameters, historical similar process task cases, and current remote sensing image metadata are used to construct system prompt words. Based on the thinking chain technology, task execution paths are constructed, and composite tasks are decomposed into atomic sub-task chains. Output the atomic task chain.

8. The remote sensing image processing system based on intelligent agents according to claim 1, characterized in that, The field adaptation middleware includes an automatic detection and mapping unit for input and output fields, a dynamic format conversion and adaptation unit, and a metadata repair unit. The automatic detection and mapping unit for input and output fields detects differences in the names, data types, dimensions, spatial references, and metadata tags of input and output fields between operators in real time. It understands the semantics of fields through a rule engine or large model and automatically associates synonymous fields. When the dynamic format conversion and adaptation unit detects inconsistencies in data types between the inputs and outputs of adjacent operators, it automatically inserts forced type conversion logic, band order adjustment, and coordinate system conversion operators. It resolves multidimensional data conflicts through structural adaptation or unifies resolution through interpolation / resampling. When key metadata is lost in the operator output, the metadata repair unit inherits and supplements it from upstream data or global configuration and automatically adds semantic tags to unlabeled data.

9. A remote sensing image processing method based on intelligent agents, implemented according to any one of claims 1-8, characterized in that, Includes the following steps: S1, at the operator layer, the prepared operators are registered through the operator registration module, and the operator metadata is stored in a vectorized form. S2, where the user inputs natural language commands at the interaction layer; S3, the natural language interaction module of the interaction layer uses a hybrid expert model to parse the natural language instructions input by the user and convert them into structured parameters. If the confidence level is lower than the threshold, it triggers multi-turn dialogue and semantic completion to achieve accurate understanding of the user's intent. S4, the process automation generation module of the interaction layer, after receiving the structured parameters converted by the natural language interaction module, decomposes the composite task into a chain of atomic sub-tasks based on the thinking chain technology. S5, the process automation generation module of the interaction layer automatically matches operators by inputting system prompts, operator meta-information and historical execution information of operators through a hybrid expert model. Then, it matches the optimal operator and optimizes the task execution path by combining the ReAct framework with the improved A* algorithm path cost function. Then, it completes the modification and confirmation of the field configuration information of the process through the field adaptation middleware of the data adaptation layer, and finally outputs the process description file. S6. When no operator is found in the operator library, the code generation sandbox is triggered and verified. After verification, the newly generated operator is registered in the operator library and added to the process. S7, after receiving the generated process, the visualization process module of the interaction layer displays it on the user interface through a directed acyclic graph (DAG), allowing users to modify the operator order and operator configuration parameters in the process by dragging and dropping and using forms. S8, the dynamic process execution engine, monitors the execution status of operators based on their resource requirements, dependencies, and the current system resource allocation and operator scheduling priority, dynamically adjusting resource allocation to achieve DAG task scheduling. It automatically saves the intermediate state to the distributed cache Redis every time three atomic subtasks are completed or the execution time reaches 120 seconds. If an operator fails during process execution, the engine backtracks to the most recent checkpoint, calls the process automation generation module to recommend an alternative operator to continue execution, and simultaneously records failure logs and updates historical performance metrics.

10. The remote sensing image processing method based on intelligent agents according to claim 9, characterized in that, In S5, after receiving the atomic sub-task chain, the automated process generation module of the interaction layer automatically matches operators by inputting system prompts, operator meta-information, and historical execution information of operators through a hybrid expert model. Then, the specific steps of matching the optimal operator and optimizing the task completion path through the ReAct framework combined with the improved A* algorithm path cost function include: S51: Construct the initial decision-making environment, receive the atomic subtask chain, and dynamically load the environment context; Dynamically loaded environment contexts include: (1) Real-time status of the operator library; (2) System-level constraints; (3) Data characteristics; S52, the ReAct framework's closed-loop decision-making process, cyclically executes the following four stages until operator matching for all atomic subtasks is completed: The first stage is the reasoning stage: Based on the current atomic subtask and environmental context, a decision-making chain is generated, and structured decision options are output. When no operator is matched in the operator library, the code generation sandbox is triggered and verified. After verification, the newly generated operator is registered to the operator library and added to the process. The second phase is the action phase: This involves invoking the improved A* algorithm path cost function to match the optimal operator and optimize the task execution path. Specific steps include: (1) Based on the dynamic topology reconstruction mechanism, analyze the data dependency relationship between atomic subtasks, reconstruct the DAG topology structure of the directed acyclic graph by splitting and merging branches, split the atomic subtasks without data coupling into independent execution flows, and realize multi-operator parallel computing; (2) Path cost optimization; The path cost function based on the improved A* algorithm is: Where Cost is the path cost of the operator; F represents the historical average time taken by the operator. rate R represents the historical failure rate of the operator. comp This represents the real-time resource contention coefficient. Weighted by time cost; For failure penalty weights; k, m, n are coefficients that can be set; GPU util For GPU utilization; CPU util For CPU utilization; mem util For memory utilization; (3) Path search process; Construct a directed acyclic graph (DAG) with atomic subtasks as nodes, initialize an open list, iteratively expand the path, and select the node with the smallest cost function f(n) at each step; Where f(n) is the total cost of executing the current node and completing the task; g(n) is the actual cost from the starting point to the current node; and h(n) is the estimated cost of the remaining subtasks. When a resource conflict is detected, an adaptive resource scheduling strategy is implemented to dynamically adjust the real-time resource contention coefficient R. comp And reorder; (4) Operator matching; For each operator subtask, select the operator with the minimum path cost from the operator candidate pool; The third stage is the observation stage: verifying the operator matching constraints and generating an anomaly report when a conflict is detected; The fourth stage is the feedback and adjustment stage: dynamic adaptation is triggered based on the conflict type, and it is carried out from the following four aspects: Insert a degradation operator when resource conflicts occur; Insert a format conversion operator when data is incompatible; Insert an automatic transpose operator when data bit depths are incompatible; For other non-predefined conflict types, add the conflict report to the environment context and return to the first phase.

11. The remote sensing image processing method based on intelligent agents according to claim 9, characterized in that, The specific steps of S6 include: S61, build code to generate prompts; S62, input the code generation prompts into the Qwen3 large model to complete the code writing, and perform code inspection and code execution inspection after the code writing is completed; S63: After the check is completed, the operator is automatically registered through the canary release mechanism and added to the process; if the check fails, the code is manually corrected, and the check is repeated after the modification is confirmed.

12. The remote sensing image processing method based on intelligent agents according to claim 9, characterized in that, In S8, the priority calculation of operator scheduling adopts a three-level priority calculation model, and the priority weight formula is as follows: Where Priority is the scheduling priority of the operator in this task flow; DepPriority is the dependency priority; ResPriority is the resource priority; and DynamicAdj is the dynamic adjustment factor.

Images