Harnessless Paradigm: openJiuwen AgentOS Enables Agent-Native Apps Without Custom Harness
openJiuwen AgentOS introduces a Harnessless development paradigm that lets developers build agent-native applications by reusing built-in agent capabilities like context management, tool calling, and multi-agent collaboration, demonstrated through examples like a 3D exploration app, a space station tutor, and a werewolf game with human-agent interaction.
Harnessless Development Paradigm for Agent-Native Applications
openJiuwen AgentOS introduces the Harnessless paradigm: application developers no longer need to build custom Harness infrastructure (context handling, tool permissions, task execution, multi-agent coordination). Instead, they reuse the platform's built-in Harness, focusing on business logic, UI interaction, and domain rules while integrating single-agent or swarm capabilities as needed.
Core Architecture
The platform provides a unified Gateway for authentication, routing, and event callbacks. AppMarket handles application registration, instance lifecycle, and status monitoring. Applications expose start/stop interfaces and report runtime status. The Agent Harness is embedded in AgentOS: single-agent path reuses session context, model invocation, and tool calling; multi-agent (swarm) path adds task decomposition, scheduling, message passing, and result aggregation. Applications retain their own UI, rules, and state, invoking execution capabilities via the Gateway.
Planned Platform Capabilities
Compute affinity (A+K)
RSI (Recursive Self-Improvement)
Trace trajectory attribution
Multimodal support
Full-duplex communication
Design patterns
SwarmFlow
These will be uniformly encapsulated for custom application development. Future support for remote distributed deployment aims to meet enterprise multi-node deployment and unified operations needs.
Example 1: "黄沙镇往事" 3D Exploration App
Built using WorkSwarm's Coding ability, this experimental 3D app lets users explore a western town. Agent participated from requirements through scene construction to interaction tuning. After user confirmation, the app is registered in the local management UI, generating a card with name, description, and launch entry. Users can edit app info, switch apps, start/stop, and view runtime status. The app evolves from a development task into a repeatedly launchable, iterable application.
Practical Demo 1: Space Station Model with Single-Agent Explanation
Users rotate, disassemble a space station model, and point at components to ask questions. The app passes the current component and user query to an explanation agent, rendering the answer in the same UI. When the user switches components, the explanation continues seamlessly. Developers handle model interaction and instructional design; single-agent session and execution are provided by AgentOS.
Practical Demo 2: Werewolf Game with Multi-Agent Swarm
A werewolf game requires multiple roles and a moderator to orchestrate phases (night actions, day discussion, voting, public information). Using AgentOS swarm mode, the app maintains game state and rules; the moderator role organizes tasks per phase, the swarm dispatches tasks to respective agents, and returns speeches, actions, and votes to the app. Night phase: moderator follows rules to trigger role actions, feeding results forward. Day phase: focus shifts to discussion and voting; agents judge based on available info and role objectives, while human player input enters the same game process as basis for next tasks. Developers concentrate on game rules, role-visible information, and outcome adjudication; task dispatch, execution coordination, and result collection reuse AgentOS swarm capabilities.
Enterprise Application Management and Legacy Integration
Existing applications can be onboarded to AgentOS for unified start/stop, runtime status, and resource configuration via a single workbench. When new features are needed, developers return to the original project from the workbench, modify code, and run the app to validate changes. Example: Agent Studio onboarding allows launching the workbench, viewing status, stopping the app, and monitoring server CPU/memory usage. Agent Studio reuses model and agent resources configured in AgentOS while preserving its original UI and workflows.
Agent-Native IDE Experience
From "黄沙镇往事" to Agent Studio, developers open original projects in WorkSwarm, edit code directly or delegate modifications to a Coding Agent, then launch the app to verify effects. This unified code-edit-and-run-verification loop is the IDE experience AgentOS aims to deliver. In the demo, a Coding Agent changed the town from day to night (v2.0), and the updated version launched directly from the app card. Another demo: from an "Edit" entry on the Agent Studio app card, a Coding Agent changed task space background to white, updated welcome copy, and bumped version to 2.0.0; refresh showed new UI and updated version on the card.
Enterprise Asset Reuse and Sharing
Enterprises often have scattered software: business systems, departmental tools, internal scripts, and small apps. Some are redundantly developed, some only runnable by original authors, some valuable but lacking discovery entry points. AgentOS aims to bring these into a unified management system: adapt existing apps, add new agent apps to the same portal, enabling discovery, reuse, and sharing under enterprise deployment and access policies. Reuse happens at two levels: reuse of already-developed applications, and reuse of AgentOS built-in Harness and agent capabilities when building new apps. The goal is to turn applications from personal projects into sustainable team software assets.
Future: REA for Rapid Agent-Native Enablement
Planned REA (Runtime Environment Adaptation) capability will extend software onboarding, letting users add needed software and explore integration with agent task execution. An experimental REA interface shows environment check results: reusable, verified, pending, and unavailable capabilities on the local machine. Users can view tool verification results, use ready capabilities, and follow prompts to manually configure missing components.
Production Readiness: A+K Compute Affinity for Agent Clusters
As agent-native apps move to production, multiple apps concurrently invoke models, sharing inference compute and VRAM. The platform must coordinate concurrent tasks and manage per-session cache occupancy. openJiuwen advances A+K compute affinity, letting AgentOS coordinate with inference infrastructure based on task and session state. Already supported: request pre-fetch, unload, and release of KV Cache by session lifecycle, reducing redundant computation and idle cache usage. For Ascend GPU clusters, openJiuwen will extend this coordination to remote distributed deployment, progressively improving resource scheduling, runtime monitoring, and log tracing to turn local demos into sustainable enterprise services.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
