openJiuwen Launches Dual-Dimensional RSI Framework for Self-Improving AI Agents

openJiuwen, an open-source AI Agent platform jointly built by Huawei's 2012 Lab, Huawei Cloud, Terminal, and Computing teams, has released a complete Recursive Self-Improvement (RSI) framework deployed on the WorkSwarm office agent. The framework addresses a core limitation of current agents: they are "deliver-and-freeze," requiring manual log review, prompt tweaking, and tool updates after each failure. RSI instead lets agents learn from real task feedback, generate improvement proposals, verify them, and retain effective changes continuously.

RSI Framework Architecture

The RSI framework is not a fixed optimization algorithm but an engineering scaffold that stabilizes diverse self-iteration tasks. It centers on three pillars: versioned optimization objects, verifiable execution evidence, and extensible algorithms. Four layers collaborate to turn task goals into executable, evaluable improvement processes:

Task Layer defines what to optimize, how to evaluate, and resource budgets.

Iteration Optimization Layer decides the next candidate and which improvements to adopt.

Execution Layer runs candidates and returns evidence.

Base Framework Layer provides unified runtime, model & context management, sandbox isolation, state recovery, and observability.

Six-Stage Closed Loop

The process strings together six stages:

Evaluation & Verification – establish a baseline.

Analysis & Optimization Localization – diagnose root causes from failures, trajectories, and metrics.

Proposal & Construction – generate candidates and re-evaluate under the same criteria.

Adoption & Fusion – resolve conflicts, combine effective improvements, produce a new version.

RSI Experience Distillation – extract methods and applicability conditions.

Archival & Stop – save results, decide whether to continue; if budget and improvement headroom remain, select a parent version for the next iteration.

Reliability stems from clear separation of concerns: AgentLoop handles single-task "reason–act–observe–feedback" while the controller manages cross-version optimization, preventing the generator's subjective judgment from replacing verification. Every piece of evidence is bound to a version and evaluation context; candidates must be re-tested after filtering, fusion, or configuration changes. Failures, invalid evidence, and negative results are all recorded, enabling later rounds to reuse successes and avoid dead ends.

Three Optimization Tracks Under a Unified Interface

Under unified task expression, stage interfaces, and lifecycle, different objects employ specialized algorithms:

Research Paper Optimization – receives research goal, initial draft or experimental materials, and evaluation criteria. Uses Frontier to select parent versions, proposes research plans, builds papers with content and experimental results, then passes paper evaluation for adoption.

Research Algorithm Program Optimization – receives program file tree, task data, and standards. Uses PUCT to select parent versions and schedule search, generates source-code modifications or fixes. Candidates are built and run; scripted evaluation, rule matching, and metric aggregation compare performance to guide the next search round.

Harness Optimization – runs the current version, diagnoses from task results and trajectories, loads candidates, and re-runs the same task set. Only improvements that pass self-evaluation are adopted; methods and applicability conditions are distilled alongside.

Harness Optimization: From Failed Cases to Pluggable Capabilities

Harness constitutes the agent's "work gear": Prompt (task understanding), Skill (domain methods), Tool (operations), and Rail (execution constraints). WorkSwarm turns failure cases into improved gear through four steps:

Build Optimization Dataset – prepare a JSON eval set; each case includes ID, task requirement, judge method, reference answer, and scoring rubric. Prioritize real failed tasks.

[
  {
    "id": "case_001",
    "input": "Task for Agent",
    "judge_method": "llm",
    "reference": {
      "solution": "Reference answer",
      "judge_rubrics": "Scoring rules"
    }
  }
]

Create Experiment – in WorkSwarm's "Experiment" page choose "Harness Optimization," fill experiment name, select optimization model, test model, initial plugin, eval set, eval method, and max epochs.

Auto Iteration – WorkSwarm runs current Harness for baseline, locates issues from failed cases and execution traces, generates candidate modifications around Prompt, Skill, Tool, and Rail. Candidates are first verified on target cases, then the full eval set is replayed to confirm overall lift without regressions. The UI shows scores, epochs, model usage, and search tree – which proposals were tried and which adopted.

Install & Use – after a valid version is produced, click "Install Plugin"; the optimal Harness is packaged and hot-loaded, no manual copying; version info is retained for rollback.

Under DeepSeek-V4-Flash task model with up to 5 epochs, Harness optimization on SWE-bench Lite Dev (23 tasks) raised pass rate from 61.0% to 87.0% . Freezing the optimized Harness and testing on Evo-Bench General 64 independent tasks lifted single-run pass rate from 60.9% to 71.9% , demonstrating generalization beyond the optimization set.

Research Paper Artifact Optimization: From Idea to Polished Manuscript

In WorkSwarm, users can generate a research paper from a concept or submit an existing paper for further refinement. In the Experiment page, select "Artifact Optimization" → "Paper," provide optimization instructions (topic, target problem, or focus areas) or a local paper folder, set max epochs, and start. The detail page displays current score, best paper, model usage, and epochs; an optimization tree records each round's version – click a node to see diffs, evaluation results, and reasons for non-adoption. On completion, preview the best artifact and one-click download the full paper.

Research Algorithm Program Optimization: Submit Task Package, Find Better Versions

For runnable, evaluable algorithm programs, WorkSwarm supports automatic multi-version search from an existing implementation. Prepare the initial program and its evaluation config; recommended to pre-install and invoke the rsi-program-dataset-creator Skill to generate a task package containing the initial program, scorecard, and run/eval metadata. Then in Experiment page choose "Artifact Optimization" → "Program," select the task package folder, and launch. During optimization the detail page shows best score, model usage, and a program optimization tree – each node is a candidate program; click to view diffs, eval results, and failure reasons. The run can be paused and resumed. On finish, one-click download the best program after multi-round search and evaluation filtering, ready for verification, integration, or further development.

Compute Affinity: Lowering Multi-Round Optimization Cost

RSI trades compute for intelligence: repeated candidate generation, task execution, and evaluation mean thousands of model calls per experiment. Prompts, tool descriptions, and task materials are reused; tool calls, evaluations, and retries cause frequent pauses and resumes. Re-computing similar contexts each round inflates latency and resource use as scale grows.

openJiuwen's compute affinity, backed by Ascend infrastructure, lets the inference engine "understand" agent task state. The framework passes Agent Hints (task run, wait, resume, end) to the engine, which actively schedules KV Cache across Ascend NPU HBM, Kunpeng CPU DDR, and remote cache pools: offload to low-cost storage during wait, pre-fetch before resume, release promptly after end. This reduces multi-round optimization latency and resource overhead.

In research algorithm program optimization experiments, enabling compute affinity yielded:

Mean TTFT (Time To First Token) down 15.83% , P90 down 19.16% .

Token-weighted KV Cache hit rate rose from 7.53% to 14.36% .

HBM peak utilization down 22.82% , DDR peak down 30.74% .

Fewer repeated pre-fills, faster first tokens, lower storage pressure.

Conclusion & Availability

openJiuwen RSI now forms an end-to-end chain from experiment creation to optimized results:

Harness optimization improves agent work methods from failure cases.

Artifact optimization polishes research papers and algorithm programs.

Compute affinity cuts redundant computation, lowering resource cost.

The dual-dimensional optimization (Harness + Artifacts) makes improvement a user-initiated, observable, reusable continuous process: every change has evidence, every adoption is verified, every round's experience informs the next. Future work will enrich search, evaluation, and fusion algorithms; strengthen cross-task experience reuse; and extend the unified architecture to model optimization and hybrid optimization, letting Harness, Artifacts, and Models co-iterate within explicit evaluation criteria, budgets, and safety boundaries.

RSI Experiment mode is live on WorkSwarm. Repositories:

WorkSwarm: https://openjiuwen.com/workswarm GitHub: https://github.com/openJiuwen-ai/ AtomGit:

https://atomgit.com/openJiuwen/