Source-linked AI summary
openJiuwen: Beyond Static Harnesses for Long-Horizon Coding Agents
openJiuwen Team, Tao Yu, Xinyu Zhang, Qianqian Chen, Xiaoneng Xiang, Chia Kwangyang, Xingchen Huang, Ran Chen, Yangkai Ding, Zheng Wang, Yeo Boon Hong, Bingzheng Gan, Enrui Hu, Shuo Cheng, Deyang Li, Ruifeng Shi, Hongbo Wang, Qi Ye, Xuefeng Jin, Zhangchun Zhao
TL;DR
Long-horizon coding agents need harnesses that compose heterogeneous capabilities and adapt execution to evidence revealed during coding. openJiuwen provides shared execution semantics and Rail-based composition, then evaluates this design across two complex coding benchmarks with strong results.
Problem
Long-horizon coding agents require a harness that can compose increasingly complex capabilities and adapt framework-controlled decisions as task evidence evolves.
Method
openJiuwen combines a shared Inner Loop/Outer Loop execution substrate, Rail-based composition across agent scales, and adaptive context, feedback, goal, and reflection mechanisms.
Results
Across SWE-bench Verified and Terminal-Bench 2.1, openJiuwen exceeds the strongest selected leaderboard results by 3.4 and 3.39 percentage points, respectively.
Takeaways & Limitations
The results support openJiuwen as a reusable harness for coordinating complex agent execution across heterogeneous long-horizon workloads.
Takeaways & Limitations
The evaluation is limited to SWE-bench Verified and Terminal-Bench 2.1, with broader controlled studies and detailed ablations left for future work.
Abstract
from arXiv · showhide
Long-horizon coding agents operate over evolving repository states while increasingly relying on heterogeneous capabilities, delegated agents, and multi-agent coordination. These trends pose two complementary challenges for the agent harness. First, developers need to compose capabilities, reconfigure execution logic, and scale increasingly complex agent systems without repeatedly rebuilding orchestration. Second, complex coding tasks continuously produce new evidence---such as semantic diagnostics, execution outcomes, task progress, and changing context relevance---that should dynamically influence subsequent runtime decisions. We characterize these challenges as Structural Composability and Runtime Adaptivity. We present openJiuwen, an open-source harness designed for both developer composability and adaptive task execution. openJiuwen provides a shared execution substrate and Rail-based capability composition across single agents, delegated sub-agents, and Swarm Flow, enabling developers to construct sophisticated agent harnesses under common execution semantics. It further adapts framework-controlled runtime decisions around a fixed model policy, allowing evolving evidence to dynamically affect context, feedback, and task control toward successful completion. We systematically evaluate openJiuwen on SWE-bench Verified and Terminal-Bench 2.1, where it achieves 82.6% and 87.19%, respectively, exceeding the strongest selected official-leaderboard point estimates by 3.4 and 3.39 percentage points. These results show that openJiuwen achieves strong performance on complex coding tasks while providing a composable and adaptive harness design.
1. Introduction
Long-horizon coding agents make the harness a systems layer for assembling capabilities and controlling execution as repository state, diagnostics, progress, and context evolve. openJiuwen addresses these challenges through Structural Composability and Runtime Adaptivity, with strong benchmark results.
- Long-horizon coding agents must maintain coherent behavior while repository state, diagnostics, task progress, and relevant context evolve.
- Structural Composability: Structural Composability assembles capabilities and execution units over a shared substrate from single agents through delegated sub-agents and multi-agent flows.Its developer-facing goal is to avoid separate execution architectures for each configuration.
- Runtime Adaptivity: Runtime Adaptivity uses newly revealed evidence to adjust context construction, semantic feedback, task continuation, and stopping around a fixed model policy.Relevant evidence includes semantic diagnostics, test outcomes, intermediate results, progress signals, context relevance, and resource pressure.
- openJiuwen: openJiuwen combines a shared Inner Loop/Outer Loop substrate with Rail-based lifecycle composition across single agents, delegated sub-agents, and Swarm Flow.Its runtime mechanisms include Context Management, Goal Mode, LSP-Driven Passive Feedback, and Self-Reflection.
- Evaluation: 82.6% on SWE-bench Verified and 87.19% on Terminal-Bench 2.1 exceed the strongest selected official-leaderboard results by 3.4 and 3.39 percentage points, respectively.
2. Related Work
Prior work improves repository interaction, executable action spaces, development environments, specialized software-engineering capabilities, and long-horizon context management. openJiuwen positions the harness itself as a reusable substrate for composing capabilities and scaling execution semantics.
- Prior systems strengthen repository interaction, executable action spaces, development environments, program-structure-aware localization, repository exploration, and multi-agent workflows.
- Studies of long-horizon agents identify repeated actions and longer, more variable failed trajectories, while Ledger maintains explicit execution state to inform subsequent work.
- Context-management approaches compress older reasoning, select task-relevant context, remove redundant trajectory content, or mask observations for efficiency.
- openJiuwen treats the harness as the primary systems layer, combining a shared execution substrate with runtime feedback, progress, and context changes that shape subsequent execution.
3. Method: Composable Structure and Adaptive Runtime Control
openJiuwen organizes its design around Structural Composability and Runtime Adaptivity over a shared execution substrate. The system overview connects Rail-based capability composition and reusable agent execution with adaptive runtime mechanisms.
- Structural composability governs composition over a shared substrate from single agents to sub-agents and multi-agent systems, while runtime adaptivity changes execution as information emerges.
- Figure 2 presents the shared execution substrate underlying Rail-based capability composition, reusable agent instances, and runtime mechanisms.The figure depicts representative rather than exhaustive Rails and runtime mechanisms.
3.1. Structural Composability
Structural Composability reuses one execution model across agent scales and attaches capabilities through ordered lifecycle hooks and visibility gating. Swarm Flow extends this substrate with composable operators for task-specific multi-agent coordination.
- Every standalone agent, delegated sub-agent, and Swarm Flow agent reuses the Inner Loop/Outer Loop engine and Rail-based capability interface.
- Inner Loop/Outer Loop: The Inner Loop handles bounded model–tool interaction, while the Outer Loop handles task-level continuation, termination, exceptions, and recovery.
- Rail-based capability composition: Lifecycle hooks let Rails observe or modify execution around model and tool boundaries without embedding capability-specific logic in the core loop.
- Rail-based capability composition: Rails execute by declared priority, with deterministic tie resolution and controlled overriding when the merge policy permits replacement.
- Capability gating: Visibility gating gives different execution subjects distinct capabilities while preserving the same substrate, supporting bounded delegation, progressive disclosure, and role isolation.
- Swarm Flow: Figure 3 illustrates a task-specific workflow in which workers generate candidates, reviewers process valid results, an arbiter aggregates feedback, and human intervention is optional.
- Swarm Flow: Swarm Flow composes operators for budget control, parallel execution, result filtering, streaming, stateful coordination, human intervention, and termination.
3.2. Runtime Adaptivity
Runtime Adaptivity changes framework-controlled execution state around a fixed model policy as evidence evolves within and across tasks. openJiuwen adapts context, feedback, acceptance, and stopping while enforcing runtime constraints.
- Runtime Adaptivity: Runtime Adaptivity adjusts context construction, semantic feedback, and acceptance or stopping decisions as new execution evidence becomes available.The framework adapts around a fixed model policy rather than updating model parameters.
- Constrained Online Runtime Adaptation: Constrained online optimization provides a conceptual lens for state-dependent runtime adjustments, not a numerical optimization algorithm.The framework uses currently available interaction history, diagnostics, goal state, context pressure, and resource status to guide adjustments.
- Constrained Online Runtime Adaptation: The runtime configuration Θt = (κt, Φt, ιt) represents context construction, acceptance and stopping, and diagnostic-feedback injection, respectively.The subscript t denotes effective state-dependent behavior rather than a newly learned mechanism at every epoch.
- Context Management: Context Management selectively transforms, compresses, offloads, and retrieves information according to context pressure, task state, and content structure.Progressive compression retains recent information at higher fidelity, while structure-aware reduction and offloading help preserve the context budget.
- Goal Mode: Goal Mode separates semantic completion or blockage from hard limits on attempts, time, or resource usage when determining whether execution continues.It supports self-assessment, independent assessment, and hybrid assessment through a shared interface.
- LSP-Driven Passive Feedback: LSP-Driven Passive Feedback mechanically produces, ranks, deduplicates, and bounds diagnostics before exposing admissible feedback to later execution.The mechanism affects subsequent decisions only after diagnostics are produced and filtered; its scope excludes architectural quality, maintainability, business-logic correctness, and end-to-end success.
- Self-Reflection: Self-Reflection extracts reusable experience after completed trajectories and makes selected experience available to future tasks without updating the model policy.Retrieved experience may still be compressed, summarized, deferred, or omitted by Context Management.
4. Experiments
The experiments evaluate openJiuwen on repository-level software engineering and broader terminal-based tasks using fixed configurations and benchmark-specific verifiers. It achieves strong results across both benchmarks, with favorable performance on tool-intensive categories and longer execution horizons.
- Results: 87.19% accuracy on Terminal-Bench 2.1 exceeds Claude Code with Fable 5 at 83.8% by 3.39 percentage points.In the model-matched Fable 5 comparison, openJiuwen reaches 84.04%, compared with 83.8% for Claude Code and 80.4% for Terminus 2.
- Category-level analysis: Fable 5 category scores favor openJiuwen on file operations at 0.76 and system administration at 0.889, versus Claude Code scores of 0.56 and 0.778.The analysis identifies these as strongly tool-dependent categories and offers broad operational tools and a unified execution interface as plausible systems-level factors, not controlled causal explanations.
- Results: 82.6% Pass@1 on SWE-bench Verified exceeds the strongest selected leaderboard result of 79.2% by 3.4 percentage points.The evaluation covers 500 human-validated repository-level software-engineering instances.
- Performance by task duration: OpenJiuwen achieves the best SWE-bench results in the < 15 minute bucket at 91.75% and the 15-minute–1-hour bucket at 81.23%.On 1–4 hour tasks, it reaches 52.38%, above mini-swe-agent at 35.71% with high and 42.86% with medium reasoning effort; the > 4 hour bucket has only three tasks.
- Overall comparison: Across both benchmarks, openJiuwen exceeds the strongest selected leaderboard result by 3.39 percentage points on Terminal-Bench 2.1 and 3.4 percentage points on SWE-bench Verified.The comparisons are system-level because leaderboard systems may differ in models, prompts, tools, and agent implementations.
5. Limitations
The paper identifies several directions for extending openJiuwen, including tighter integration of execution experience, hierarchical goals, automated context-strategy coordination, and broader evaluation.
- Future work could more tightly integrate runtime Self-Reflection with offline evolution to systematically reuse execution experience.
- Goal Mode currently focuses on task-level objectives; extending it to hierarchical goals may improve control over complex, multi-stage tasks.
- Future work could automate selecting and coordinating Context Management strategies under different runtime conditions.
- The evaluation covers SWE-bench Verified and Terminal-Bench 2.1, leaving broader studies across benchmarks, models, configurations, and detailed ablations for future work.
6. Conclusion
The paper presents openJiuwen as a composable and adaptive coding-agent harness addressing Structural Composability and Runtime Adaptivity. Its shared execution architecture and adaptive runtime mechanisms support strong performance on complex coding tasks while reducing development effort.
- openJiuwen addresses Structural Composability and Runtime Adaptivity as complementary challenges for coding-agent harnesses.
- Its shared Inner Loop/Outer Loop substrate, Rail-based composition, and reusable semantics span single agents, delegated sub-agents, and multi-agent coordination.
- Goal Mode, LSP-Driven Passive Feedback, Context Management, and Self-Reflection adapt framework-controlled runtime decisions using evolving execution evidence.
- Evaluations on SWE-bench Verified and Terminal-Bench 2.1 demonstrate strong performance across repository-level software engineering and broader terminal-based tasks.
- The results show that a composable harness architecture can support efficient agent development and effective execution on complex coding tasks.
A. Author List
The paper lists its core contributors.
- The core contributors are Tao Yu, Xinyu Zhang, Qianqian Chen, Xiaoneng Xiang, Chia Kwangyang, Xingchen Huang, Ran Chen, Yangkai Ding, Zheng Wang, Yeo Boon Hong, Bingzheng Gan, Enrui Hu, Shuo Cheng, Deyang Li, Ruifeng Shi, Hongbo Wang, Qi Ye, Xuefeng Jin, Zhangchun Zhao.