A method and system for preventing duplicate submissions and continuous orchestration of intelligent agent remote jobs.

By using three-domain identity anchoring and persistent identity binding, the problem of repeated submissions by intelligent agents in unstable network environments is solved, and unique management and continuous orchestration of multi-round computing tasks are achieved on traditional schedulers.

CN123114751APending Publication Date: 2026-11-17颜帅
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611305056.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-26
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In remote computing tasks driven by intelligent agents based on probabilistic models, how can we prevent the repeated submission of the same logical job and restore the trusted external job identity in multi-round and cross-session computing tasks when the remote batch processing scheduler does not accept client idempotent keys and the network response is uncertain?

Method used

By establishing a three-domain identity anchor between local action identity, scheduler visible identity, and scheduler assigned identity, logical submission actions are determined using run identifiers and idempotent keys, a submission token is generated, and identity binding is persisted before the scheduler job identifier is returned. Reconciliation is performed using activity queues and historical records to ensure job uniqueness.

Benefits of technology

It enables remote job submission to be performed only once when the network response is uncertain, avoiding repeated resource consumption, supporting continuous orchestration of multi-round decision-making and long-term computing tasks, and without requiring modification of the traditional scheduler.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114751A_ABST
    Figure CN123114751A_ABST
Patent Text Reader

Abstract

This invention discloses a method and system for preventing duplicate submissions and continuously orchestrating remote jobs using an intelligent agent. For remote batch processing schedulers that do not accept client idempotent keys, the system maps agent candidate actions to typed action specifications, deriving deterministic job names from run identifiers and idempotent keys, and saving the specifications, scripts, and input digests before submission. The credential-isolated executor verifies the path and digest before submitting only once; if the response is lost, unresolvable, or the identity verification is inconsistent, it enters the `submission_uncertain` state, prohibiting the resubmission of the same action, and sequentially queries the activity queue and historical records by job name, restoring or maintaining indeterminacy based on unique, zero, or multiple matches. Persistent reconciliation evidence and job status feedback agents enable the system to continue multi-round, multi-job orchestration after session interruption or restart, reducing duplicate submissions and incorrect identity bindings.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the fields of distributed computing, remote batch job scheduling, artificial intelligence agent control, and computer software reliability. In particular, it relates to a method and system for preventing duplicate submissions, restoring identity, continuously monitoring, and orchestrating across sessions for remote jobs under conditions where intelligent agents make multi-round decisions, remote communication responses may be lost, and the remote batch scheduler does not receive client idempotent keys. Background Technology

[0002] Tasks such as computational physics, computational chemistry, engineering simulation, model training, and data processing typically last from hours to months, and are driven by research protocols involving multiple rounds of remote file preparation, batch job submission, queue monitoring, result checking, parameter tuning, and subsequent job decisions. While probabilistic model-based intelligent agents can adjust their work plans based on continuously generated results, actions regenerated under the same state may differ in their textual or parameter expressions. Therefore, the continuity of dialogue or identical action text cannot be considered the sole identity of external side effects.

[0003] Traditional remote batch processing schedulers such as LSF, Slurm, and PBS typically receive scripts and job names via command-line submission interfaces and assign a scheduler job identifier upon successful reception. Some traditional interfaces do not accept idempotent keys for client deduplication. When the scheduler has received a job but the SSH connection is interrupted, the response is lost, the returned text is unparseable, or the client restarts before obtaining the job identifier, the client cannot determine whether the job has entered the scheduler based solely on the call result. If a smart agent or a general retry framework resubmits the job, there is a risk of duplicate jobs, duplicate consumption of computing resources, and overwriting of artifacts.

[0004] Existing proxy governance schemes can convert proxy outputs into typed actions and perform permission or boundary checks before execution. However, a single action being deemed permitted does not guarantee safe re-execution after an uncertain response. Existing idempotent commit interfaces typically require the server or scheduler to receive a unique client identifier and discard duplicate requests, making them unsuitable for traditional schedulers that do not support this interface. Even if existing job management schemes store local job identifiers and scheduler job identifiers, they usually assume that the scheduler job identifier has been successfully obtained, failing to address how to prevent nondeterministic smart proxies from repeatedly generating commit side effects and how to restore external identities when this identifier has not yet been returned.

[0005] Therefore, an application-layer mechanism is needed that does not modify the traditional remote batch processing scheduler, solidifies the action identity before external submission, enters a non-resubmittable state when the submission response is uncertain, and establishes a recoverable identity association using the scheduler's existing job names, activity queues, and historical records, so that the intelligent agent can continue to make decisions in long-term, multi-round, and cross-session computing tasks without repeatedly submitting the same logical job. Summary of the Invention

[0006] The technical problem this invention aims to solve is: in the case of a probabilistic model-based intelligent agent driving remote computing tasks, where the submission interface of the remote batch processing scheduler does not accept client idempotent keys and network response or agent session may be interrupted, how to distinguish between states that have not yet been submitted, have been submitted but have not obtained job identifiers, and have identity conflicts without modifying the scheduler, prevent the same logical job from being submitted repeatedly, and restore the trusted external job identity for subsequent rounds of orchestration.

[0007] To address the aforementioned technical problems, this invention establishes a three-domain identity anchoring system among the local action identity, the scheduler-visible identity, and the scheduler-assigned identity. First, a logically submitted action is uniquely determined using a run identifier and an idempotent key, and a digest is calculated based on the typed action specification, job script, and input snapshot. Then, a submission token and a scheduler-visible job name are deterministically derived from the run identifier and idempotent key. Finally, after obtaining and verifying the scheduler job identifier, this job identifier is bound to the aforementioned local action identity and scheduler-visible job name.

[0008] Before any external commit call, the system writes a transaction to the prepared job record, binding at least the run identifier, idempotent key, action specification summary, commit token, deterministic job name, remote endpoint, normalized working directory, script summary, input summary, and resource request, and imposing a unique constraint on the combination of run identifier and idempotent key. After the executor revalidates the remote path and remote script and input file summary, it calls the remote commit interface only once.

[0009] When the response is parsable and the job name retrieved based on the returned scheduler job identifier matches the deterministic job name, the system binds the scheduler job identifier. If the connection is interrupted, the response cannot be parsed, multiple identifiers are returned, or the job name is inconsistent, the system converts the record to the `submission_uncertain` state; subsequent requests with the same run identifier and idempotent key will only return existing records or generate conflicts, and the submission interface will not be called again.

[0010] For the `submission_uncertain` record, the system first queries the activity queue by deterministic job name, then queries the historical records, and combines the query source, number of matches, candidate job identifier, status, and observation time to form reconciliation evidence. A unique match binds the job identifier; multiple matches remain uncertain and subsequent submissions are blocked; a zero match occurs after a safe waiting period and at least a second zero-match query is executed. This, combined with the classification of whether the exception occurred before or after the submission call, determines whether the submission was not completed or remains uncertain.

[0011] Persistent reconciliation evidence, non-final job states, and next check times are written to the smart agent context. After a smart agent session is interrupted or the system restarts, the new agent instance must first restore the prepared or submission_uncertain records and complete the reconciliation before it can generate any subsequent submission actions that may conflict with them. Thus, under the combined conditions of probabilistic agent planning, uncertain communication results, and the scheduler lacking an idempotent client interface, it achieves a near-one-time remote job submission effect, and supports multiple job submissions and long-term continuous orchestration.

[0012] Beneficial effects

[0013] Compared to schemes that only save records after the scheduler returns the job identifier, this invention persists the complete identity binding before external side effects occur, and can retain recovery anchors when the return response is lost.

[0014] Compared to schemes that rely on the scheduler to receive idempotent keys from clients, this invention uses the scheduler's existing job names, activity queues, and historical records to achieve application-layer deduplication and identity restoration without modifying the traditional scheduler.

[0015] Compared to schemes that only perform intelligent agent permission or action boundary verification, this invention further uses uncertain external side effect states as persistent blocking conditions to prevent allowed actions from being executed twice due to agent replanning, session restart, or network retries.

[0016] By verifying the specification summary, script summary, input snapshot summary, and post-commit job name, we can avoid incorrectly binding jobs with content drift to the same commit; and by using unique, zero, and multiple matching branches, we can avoid incorrect recovery when identity conflicts have not been resolved.

[0017] By using next check time, heartbeat lease, product validity, and evidence feedback, multi-round computational tasks can be managed over the long term without frequent polling, and plan updates can be based on verified remote status. Attached Figure Description

[0018] Figure 1 This is a schematic diagram of the overall architecture of the intelligent agent planning domain and the deterministic commit recovery domain of the present invention.

[0019] Figure 2 This is a schematic diagram illustrating the three-domain identity anchoring relationship of the local action identity, scheduler visible identity, and scheduler assigned identity in this invention.

[0020] Figure 3 This is the main flowchart of the remote operation anti-duplicate submission and continuous scheduling method of the present invention.

[0021] Figure 4This is a flowchart illustrating the reconciliation process between the activity queue and historical records in the submission_uncertain state of this invention.

[0022] Figure 5 This is a flowchart of the remote job monitoring, heartbeat lease, and cross-session recovery process of the present invention.

[0023] Figure 6 This is a schematic diagram of the closed-loop arrangement of multiple rounds and multiple tasks in the long term in this invention. Detailed Implementation

[0024] The present invention will be further described below with reference to the accompanying drawings and embodiments. The embodiments are for illustrative purposes only and are not intended to limit the scope of protection. Unless otherwise specified, the hash algorithm may be SHA-256 or other hash algorithms with collision resistance, and the persistent storage may be a relational database, a transactional key-value store, or a storage system with equivalent uniqueness constraints and atomic commit capabilities.

[0025] The intelligent agent in this specification refers to a program module that generates candidate actions based on a probabilistic model, including but not limited to large language model agents. Candidate actions are merely planning outputs and do not have remote submission permissions. The action protocol gateway maps candidate actions to ActionSpecs with fixed fields and versions; the credential isolation executor only accepts ActionSpecs that have passed deterministic verification and have been written to the prepared record.

[0026] A remote batch scheduler is a scheduling system capable of receiving job scripts and job names, assigning scheduler job identifiers, and querying the active queue and history, but whose submission interface does not accept idempotent keys for client requests to deduplicatize data. LSF's bsub / bjobs / bhist, Slurm's sbatch / squeue / sacct, and PBS's qsub / qstat / history query can be implemented as submission, active query, and history query interfaces, respectively.

[0027] Example 1: Overall Architecture and Permission Separation

[0028] like Figure 1 As shown, the system includes a task target and confirmation boundary 100, an intelligent agent 200, a persistent state library 300, an action protocol gateway 400, a constraint verification and pre-writing module 500, a credential isolation executor 600, a remote batch processing scheduler 700, an uncertain submission reconciliation module 800, and a monitoring and evidence module 900.

[0029] The task's acceptance boundaries must at least record the allowed remote endpoints, task write root, resource limits, concurrency limits, automatic retry limits, and completion evidence conditions. The work plan can be modified within the acceptance boundaries based on calculation results; expanding endpoints, write ranges, resources, or scientific retry commitments creates pending acceptance items. The aforementioned boundaries limit the scope of side effects, but the anti-duplicate submission identity of this invention remains effective after boundary verification.

[0030] The intelligent agent 200 can only submit candidate actions through the action protocol gateway 400, cannot read remote credentials, and cannot directly invoke the scheduler 700. The executor 600 holds the remote credentials and only produces remote side effects for actions where the recorded state, specification digest, and verification result all match. This separation of permissions ensures that natural language, retry suggestions, or forged receipts in the intelligent agent's output cannot bypass the `submission_uncertain` blocking state.

[0031] Example 2: Three-Domain Identity Anchoring and Data Structure

[0032] like Figure 2 As shown, the local action identity 310 consists of run_id, idempotency_key, and ActionSpec digest. ActionSpec includes at least the action type, stage identifier, remote endpoint, normalized remote working directory, remote script path, script digest, set of input file digests sorted by path, resource request, monitoring policy, and prior evidence reference.

[0033] ActionSpec is normalized and serialized according to the schema version: object keys are arranged lexicographically, path separators are standardized, time is converted to UTC, collection semantic arrays are deduplicated and sorted, text is encoded in UTF-8, and non-finite values ​​are rejected. The normalization result is used to calculate spec_sha256. The database imposes a uniqueness constraint on (run_id, idempotency_key); when the same combination corresponds to different spec_sha256, IDEMPOTENCY_CONFLICT is returned, and the new specification is not overwritten on the old record.

[0034] The scheduler-visible identity 320 includes a submission_token and a job_name. In one implementation, the submission_token is the first N bits of a SHA256 hash (fixed namespace || run_id || idempotency_key), and the job_name consists of a fixed prefix and the first M bits of the submission_token; N and M are chosen based on scheduler name length constraints. The derived algorithm and version are written to the prepared record.

[0035] The scheduler assigns an identity 330, including job_id and job_status. The job_id is bound only after the submitted response is resolvable and the job_name is verified by a query, or after a unique match is obtained without certainty regarding reconciliation. The prepared record 340 stores at least the above three fields, host, remote_workdir, script_sha256, inputs_sha256, resources_json, created_at, and status. The ReconciliationEvidence 350 stores at least the query source, job_name, number of matches, candidate job_ids, candidate status, original response summary, and observed_at.

[0036] A state machine 360 ​​includes at least the following states: prepared, submission_uncertain, submitted, running, terminal, and reconciled_not_submitted. State transitions are controlled by a permissible transition table and transactions; intelligent agents cannot directly edit them. For the same idempotent request to a prepared or submission_uncertain record, only the existing record is read; subsequent commits are only allowed when the state is explicitly reconciled_not_submitted and a new action identity expresses a new commit intention.

[0037] Example 3: Pre-submission validation and single external call

[0038] like Figure 3 As shown, the system constructs the AgentContext from the confirmed boundary, current plan, unfinished jobs, and evidence, and the intelligent agent generates candidate actions based on this. The action protocol gateway only accepts fields that can be mapped to the enumerated capability job.submit; unmapped free text cannot directly enter the executor.

[0039] The system resolves endpoint bindings and the task write root locally, performs normalization on the remote working directory, and verifies that it is located within the task write root. The remote executor again obtains the canonical paths of the task write root and the working directory, handling point paths, name prefixes, and symbolic link escapes; subsequently, it performs digest calculations on the remote script and each remote input, comparing each digest with the digest in the prepared record. Any path out-of-bounds errors, input drifts, resource out-of-bounds errors, or digest inconsistencies are blocked before the commit interface is called.

[0040] After all validations pass, the executor constructs a commit call using the job_name in the prepared record, for example, by executing `bsub -J job_name` and passing the script to standard input. "Once" means that the prepared record can only be called if the commit interface has never been invoked; once the call begins, regardless of whether a resolvable response is obtained, the record cannot return to the prepared branch where it can be directly committed again.

[0041] If the response contains a unique job_id, the system immediately queries the scheduler using the job_id and verifies the returned job_id and job_name. If both match, the job_id is bound and the process enters either submitted or running. If the query fails, the job_id is inconsistent, or the job_name is inconsistent, submission failure is not assumed, and the process enters submission_uncertain. This avoids misjudgments when successful return text is truncated or when a different job identity is returned.

[0042] Example 4: Uncertainty in submitting reconciliation

[0043] like Figure 4 As shown, when there is a connection error, timeout, empty response, unparseable response, response containing multiple job_ids, or inconsistent identity verification after submission, the system retains the prepared identity field and converts it to submission_uncertain. This state forms a persistent latch for the same run_id and idempotency_key, preventing a second submission call from being triggered by intelligent agent rescheduling, user refresh requests, process restarts, or network retries.

[0044] In the first query phase, the activity queue is retrieved by deterministic job_name. If exactly one different job_id matches, the candidate status is saved and bound to that job_id; if multiple different job_ids match, all candidates and conflict evidence are saved and the process remains uncertain; if zero matches, the process proceeds to the historical query phase without immediately determining whether a submission has been made.

[0045] The second query phase retrieves scheduler history records for the same job_name. A unique match binds the job_id and restores its final or non-final state; multiple matches remain indeterminate; zero matches record an empty observation. The system executes the active queue and history queries at least again after a safe waiting period for the visibility delay in the overlay queue. Only if at least two rounds result in zero matches, and the exception classification proves the submission command did not reach the scheduler or the pre-scheduler explicitly rejected it, does it transition to reconciled_not_submitted; otherwise, it remains submission_uncertain and is handed over to subsequent reconciliation.

[0046] In one LSF implementation, activity queries are filtered by job_name using bjobs; if no job is found, bhist is used to query recent historical events. The output is first deduplicated into a set of job_ids, then transitioned by zero, unique, or multiple execution states. Reconciliation evidence preserves the output summary without relying on the intelligent agent's subjective judgment of the free text.

[0047] Example 5: Continuous monitoring and cross-session recovery

[0048] like Figure 5 As shown, each non-final state job record includes the estimated time, initial check time, queued check interval, running check interval, interval basis, and next_check_at. External wake-up tasks are triggered based on the earliest next_check_at currently running, only querying expired jobs to avoid fixed high-frequency polling.

[0049] Heartbeat leases store wake-up task references, schedule cadence, last update time, and lease expiration time. If a prepared, submission_uncertain, submitted, pending, or running job has an expired lease, the system marks the job as unmonitored and prevents the agent session from silently terminating without establishing subsequent monitoring. When all jobs are in final state and there are no subsequent jobs, the wake-up task is deleted and a shutdown receipt is saved.

[0050] After an agent session is interrupted or the system restarts, the new agent instance reads the current boundary summary, job plan version, prepared and submission_uncertain records, bound job_id, most recent observation, and evidence by run_id. The recovery order is to first reconcile indeterminate commits, then query bound non-final state jobs, and finally construct the AgentContext that allows the generation of new commit actions; it does not depend on the original conversation text or the original agent instance continuing to exist.

[0051] Example 6: Multi-round decision-making, product effectiveness, and minimum recalculation

[0052] like Figure 6 As shown, a run can consist of multiple phases, multiple job submissions, and long time intervals. The status, standard output summary, result file summary, and verification conclusions generated by remote jobs are converted into structured evidence and fed back to the intelligent agent to decide whether to continue the current phase, adjust parameters, submit subsequent jobs, roll back the affected phase, or terminate the run.

[0053] Product records have validity status: valid, suspect, invalid, or superseded. When new evidence renders an upstream product invalid, the original product and the generated action are retained, without silent overwriting; only the stages that depend on that product are reopened. Scientific retry actions form a single chain of the same stage and capability via `retry_of_action_id` and are constrained by the maximum number of automatic retries in the confirmation boundary; uncertainty in connection, authentication, transmission, and submission responses does not consume scientific retry counts.

[0054] Completing the check requires at least the absence of prepared, submission_uncertain, or other non-final state jobs, the absence of any blocking pending items, and the passing of the entire evidence set. Therefore, this invention does not submit only one job after a single confirmation, but rather supports intelligent agents to make multiple rounds of management decisions and submit multiple remote jobs within a single confirmation boundary, while independently persisting the external identity and uncertain state of each submission.

[0055] Example 7: Effects of Fault Injection and Verifiable Technology

[0056] Test 1: Cause the scheduler to interrupt the SSH connection after receiving the job but before returning the job_id. The expected behavior is that the database already has a prepared record and it is converted to submission_uncertain; when requesting again with the same idempotent key, the remote submission call count will still be one; after querying the active queue by job_name to obtain a unique job, it is bound to job_id.

[0057] Test 2: Make the submission response unresolvable, and the job has finished quickly and is no longer in the activity queue. Expect zero-matches in activity queries, unique matches in historical queries, and recovery of the job_id and final state from historical records. Test 3: Artificially create two remote jobs with the same job_name. Expect reconciliation to yield multiple candidates and maintain `submission_uncertain`, without selecting either one.

[0058] Test 4: Explicitly reject the commit command before it reaches the scheduler. The expected outcome is to preserve the rejection evidence and convert it to `reconciled_not_submitted`, requiring subsequent commits to use the new action identity. Test 5: Modify a remote script or input file after the action is generated. The expected outcome is digest verification blocking and a zero commit call count.

[0059] Test 6: Terminate the agent session and restart the system in the `submission_uncertain` state. The new session is expected to restore existing records and reconcile accounts; no conflicting commits should occur before the state is cleared. The results can be verified using database unique constraints, remote call records, scheduler queues and historical output, state transition logs, and evidence digests.

[0060] During the implementation verification prior to the application date, all twenty local regression tests related to job output parsing, monitoring rhythm, at least two empty reconciliations for uncertain submissions, disk write before submission, identity verification after submission, no resubmission for uncertain responses, and explicit pre-scheduler rejection classification were passed; the tests used one-time states and simulated remote interfaces, without connecting to the user's official database or supercomputer.

[0061] Optional implementation methods

[0062] Deterministic job names can also be derived from keyed message authentication codes, UUIDv5, or other algorithms that stably output the same run identifier and idempotent key, and can be supplemented with check bits or truncated conflict detection fields. For schedulers that do not allow duplicate job names, name uniqueness can be used directly; for schedulers that allow duplicate names, branches are still based on the number of matches without assuming globally unique names.

[0063] Remote communication can be achieved via SSH, HTTPS, or messaging channels; the remote job scheduler can be for LSF, Slurm, PBS, container batch systems, or systems that provide equivalent commit, active query, and historical query capabilities and do not receive client idempotent keys.

[0064] This invention can be used in computational physics, computational chemistry, engineering simulation, parameter search, model training, data processing, and other computational tasks that require remote connection, multiple job submissions, and long-term state management, without relying on specific materials, solvers, or research fields.

Claims

1. A method for preventing duplicate submissions and continuously orchestrating remote jobs using an intelligent agent, executed by a computer system comprising a processor, persistent memory, an intelligent agent generating candidate actions based on a probabilistic model, a credential isolation executor, and a remote batch processing scheduler, wherein the submission interface of the remote batch processing scheduler receives the job script and job name, returns the scheduler job identifier, and does not accept idempotent keys used for client requests to deduplicatize, characterized in that, include: Based on the run identifier, the current work plan, non-final remote jobs, and structured evidence are read from the persistent storage to construct an agent context. The intelligent agent then generates remote job candidate actions that do not directly invoke the remote batch scheduler based on the agent context. The remote job candidate actions are mapped to typed action specifications through an action protocol gateway. The typed action specifications include at least the run identifier, stage identifier, remote endpoint, normalized remote working directory, job script summary, input file summary set, resource request, and idempotent key. The typed action specifications are then normalized and serialized, and a specification summary is calculated. A commit token is deterministically derived based on the run identifier and the idempotent key, and a deterministic job name visible to the scheduler is formed based on the commit token; Before calling the submission interface, the prepared job record is written to the persistent storage via a transaction. The prepared job record is bound to the run identifier, the idempotent key, the specification digest, the submission token, the deterministic job name, the remote endpoint, the normalized remote working directory, the job script digest, the input file digest set, and the resource request. A unique constraint is applied to the combination of the run identifier and the idempotent key. After confirming that the remote specification path is located within the pre-registered task write root and that the current digests of the remote job script and the remote input file are consistent with the job script digest and the input file digest set, the credential isolation executor calls the submission interface only once using the deterministic job name, wherein the remote access credentials are unavailable to the smart agent; when the response of the submission interface contains a unique scheduler job identifier, the remote job is queried according to the scheduler job identifier and the queried job name is checked against the deterministic job name, and if they are consistent, the scheduler job identifier is bound to the prepared job record; When the submission interface experiences a connection error, fails to parse the response, returns multiple scheduler job identifiers, or the job name is inconsistent, the prepared job record is converted to a submission_uncertain state, ensuring that subsequent requests with the same run identifier and idempotent key return the existing record without calling the submission interface again. For job records in the submission_uncertain state, the activity queue and history of the remote batch processing scheduler are queried sequentially according to the deterministic job name. The query source, number of matches, candidate scheduler job identifiers, candidate states, and observation time are persisted as reconciliation evidence. When a unique match is obtained, the corresponding scheduler job identifier is bound. When multiple matches are obtained, the submission_uncertain state is maintained. When there is zero match, at least a second round of activity queue and history queries is performed after a safe waiting period. After the session of the intelligent agent is interrupted or the computer system is restarted, the prepared job record, submission_uncertain state, and reconciliation evidence are restored according to the run identifier. After completing the corresponding identity verification or reconciliation, the remote job state and the reconciliation evidence are written into a new agent context to continue the work plan.

2. The method according to claim 1, characterized in that, The intelligent agent modifies the work plan within a confirmed execution boundary, which includes at least a set of allowed action capabilities, a remote endpoint identifier, a remote task write root, a single job resource limit, a concurrent job limit, an automatic retry limit, and a completion evidence set. After normalization, the execution boundary is used to calculate a boundary summary and is associated with and saved with the run identifier. Candidate actions that require changes to the remote endpoint, remote task write root, resource limit, retry limit, or completion evidence set are blocked before a new confirmed execution boundary is formed.

3. The method according to claim 1, characterized in that, The normalized remote working directory is parsed for path separators, dot paths, case rules, and symbolic link targets, and the parsed task is used to determine the path dependency relationship at the root. The file descriptions in the input file digest set are sorted according to the task root relative path and include at least the relative path, file size, and content digest. When the current digest is inconsistent, INPUT_DRIFT evidence is generated and the submission interface is not called.

4. The method according to claim 1, characterized in that, The submission token is obtained by extracting the cryptographic digest of the concatenated value of the fixed namespace, the run identifier, and the idempotent key. The deterministic job name is composed of a fixed prefix and at least a part of the submission token. When the specification digests corresponding to the same run identifier and idempotent key are inconsistent, an idempotent conflict is generated and the prepared job record is not overwritten. Post-submission verification based on the scheduler job identifier compares the scheduler job identifier and the deterministic job name.

5. The method according to claim 1, characterized in that, The reconciliation query first extracts and deduplicates the set of scheduler job identifiers that match the deterministic job name from the activity queue. If the set is empty, it then extracts and deduplicates the set of scheduler job identifiers from the history. If any set contains more than one scheduler job identifier, it saves evidence of conflict and does not select any of them. If at least two rounds of queries result in zero matches and the exception is determined to have occurred before the submission command reaches the remote batch scheduler or when the remote batch scheduler explicitly refuses to submit, the job record is converted to reconciled_not_submitted. Otherwise, the submission_uncertain state is maintained.

6. The method according to claim 1, characterized in that, Each non-final state remote job stores the estimated time, first check interval, queued check interval, running check interval, the basis for forming each interval, and the next check time; the external wake-up task is triggered according to the earliest next check time of multiple non-final state remote jobs in the same running state and only queries expired jobs; a heartbeat lease is formed based on the reference of the external wake-up task, the expected wake-up rhythm, and the most recent update time, and when the heartbeat lease expires, the corresponding running is marked as unmonitored.

7. The method according to claim 1, characterized in that, The artifacts produced by remote jobs include a summary of the content, an action identifier, a set of input file summaries, and the validity of one of the following: valid, suspect, invalid, or superseded. Subsequent actions of failed actions form a single chain within the same operation, phase, and capability through retry source identifiers and are subject to an automatic retry limit. Connections, authentications, transmissions, and the submission_uncertain state are not counted in the scientific retries. Completion of the work plan requires at least the absence of prepared, submission_uncertain, or other non-final remote jobs and the passing of the completion evidence set.

8. A smart agent remote job anti-duplicate submission and continuous orchestration system, characterized in that, the submission interface receives the job script and job name, returns the scheduler job identifier, and does not accept idempotent keys used for client requests to deduplicatize, and is a remote batch processing scheduler. include: The agent context construction module is used to read the job plan, non-final remote job, and structured evidence from persistent storage and construct the agent context. A probabilistic model-based intelligent agent is used to generate candidate actions that do not directly invoke the remote batch processing scheduler based on the agent context. An action protocol gateway is used to map the candidate actions to a typed action specification that includes a run identifier, a remote endpoint, a normalized remote working directory, a job script summary, a set of input file summary, a resource request, and an idempotent key. It calculates the specification summary, deterministically derives a commit token and a deterministic job name visible to the scheduler based on the run identifier and the idempotent key, and writes a prepared job record bound to the above fields and constrained by the uniqueness of the combination of the run identifier and the idempotent key before remote commit. A credential isolation executor is used to call the submission interface only once using the deterministic job name after the path, job script digest, and input file digest have been verified. In the event of an abnormal response or inconsistency in identity verification after submission, the prepared job record is converted to the submission_uncertain state, wherein remote access credentials are unavailable to the smart agent. The uncertain submission reconciliation module is used to sequentially query the activity queue and historical records according to the deterministic job name, form reconciliation evidence including query source, number of matches, candidate scheduler job identifier, candidate status and observation time, and perform different state transitions according to unique match, multiple match or zero match; It also includes a state recovery and continuous orchestration module, which is used to restore prepared job records, submission_uncertain status and reconciliation evidence after the smart agent session is interrupted or the system is restarted, and write the remote job status and reconciliation evidence into the new agent context after identity verification or reconciliation.

9. An electronic device, comprising a processor, a memory, and a communication interface, characterized in that, The memory stores a computer program, which, when executed by the processor, causes the electronic device to perform the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method described in any one of claims 1 to 7.