CoworkOS:Scaling Agent Coworkers for Real-world Automation

AI summary

Overview

Research area: AI agent systems — specifically "agent cowork" harnesses that coordinate LLM-based agents and humans over long-horizon productivity work.

Technical level: Advanced. The paper assumes familiarity with agent frameworks (ReAct, MetaGPT, OpenHands), tool orchestration, context management, and model post-training pipelines.

Scope (one sentence): The paper introduces CoworkOS, a three-layer agent harness (Main Agent, Coordinator Runtime, Subagents) with a shared human–agent application layer and persistent workspaces, evaluated on 12 benchmarks and 6 categories of real-world applications, plus a five-round recursive self-improvement post-training case study.

What This Paper Is About

Cowork agents—AI systems that work alongside people on software, documents, designs, and other artifacts—must do two hard things at once: deliver high-quality results on complex productivity tasks, and keep monitoring and making decisions over long stretches of time (days of training runs, multi-session projects, external events). Current harnesses tend to handle one or the other well, not both, and they rarely let humans step into the middle of ongoing work naturally.

CoworkOS addresses this with a design principle of separating task strategy from execution management: the model decides what to do, delegate, and accept, while the runtime maintains state, durable coordination, and feedback. The goal is a single harness that supports complex deliverables, sustained supervision, and continuous human participation.

Key Contributions

1. A cowork harness architecture combining complex productivity work with long-horizon supervision. A division of responsibility lets the model choose task-execution strategy while the runtime maintains long-horizon mechanisms. The three-layer framework — Main Agent, Coordinator Runtime, and optional Subagents — supports collective intelligence on hard tasks and continued monitoring on sustained ones, with synchronous and asynchronous delegation, durable queues, leases, acknowledgements, and a minimal Subagent-to-Subagent peer channel.

2. A human-in-the-loop scalable application ecosystem. Foundational tools (CLI execution, search, file operations, MCP interfaces) plus extensible professional applications (text documents, presentations via PPTist, parametric CAD, Blender, with MCP integrations for FreeCAD, Blender, CAD, and OfficeHarness). Its distinctive feature is the shared application object: humans and agents inspect and revise the same evolving document, model, or scene, so human input can enter through conversation or by directly editing the artifact. A resource protocol with revision checks makes mixed human–agent editing an auditable sequence of accepted changes and rejects stale proposals as conflicts rather than silently overwriting.

3. Persistent working state and execution continuity. Hierarchical workspaces (agent working areas, Run records, published artifacts in separate scopes) plus persistent semantic memory keep files, decisions, and unfinished work shareable and reusable across agents. Long-running operations run as Jobs that retain status and logs, and checkpointing lets work resume accurately after waiting or interruption — with the runtime rejecting a "wait" that has neither an active observation source nor an explicit review time.

4. Cross-domain generalization with RSI-native capability. Performance comparable to strong mainstream cowork frameworks across 12 benchmarks in four domains (tool use, productivity, search, ML coding) and across 6 categories of real-world cowork scenarios, plus a five-round recursive self-improvement post-training study that raises Qwen3.6-35B-A3B's average score from 33.19 to 42.95 across eight benchmarks.

Main Findings

• Competitive against frontier cowork harnesses. Across 12 benchmarks in four domains and 6 categories of real-world applications, CoworkOS is reported as highly competitive with frontier agent applications such as Codex and DeepSeek Harness; the paper also names OpenHands as a comparison point. Per-benchmark scores for these comparisons are not reported in the accessible content (Figure 2(c) shows an overview across 10 benchmarks in four domains).

• Six categories of real-world artifacts produced. Figure 1 presents 24 application cases spanning frontend websites, games, Office presentations, interactive visualizations, CAD, and Blender rendering — two views per case showing different pages, scenes, or inspection states.

• RSI post-training gain of 9.76 points. Using GLM-5.3 as the backbone, CoworkOS ran RSI-driven automated post-training on Qwen3.6-35B-A3B. Over five improvement rounds, the average score across eight benchmarks rose from 33.19 to 42.95, a gain of 9.76.

• Both task dimensions can be handled by one framework. The paper frames agent difficulty along two axes — task complexity (interdependent decisions, branching, tool/evidence combination) and temporal extent (how long the objective stays active) — and positions RSI as their intersection: analyze weaknesses, wait for training and evaluation, use results to guide further work.

Methodology in Plain English

The researchers start from a formal task definition: a task is an objective plus an environment, an action space, an acceptance criterion, and a resource budget. The environment changes through agent actions, human instructions or direct edits, and external events, and acceptance means meeting the criterion within budget.

On top of that formalism, they build the harness in three parts:

• Hierarchical runtime. A Main agent holds the full task context, talks to the user, plans, executes, and reviews. When work is context-heavy or independent, Main delegates to Subagents with isolated contexts, handing over only an objective, bounded background, granted tools, and a compact skill catalog — a "delegation as evidence contract." A Coordinator moves evidence across context boundaries without merging them, keeping assignment state durable so guidance and results survive interruptions. Delegation can be synchronous (result stays on the calling path) or asynchronous (an acknowledgement and identifier come back, and the outcome lands in Main's Inbox later).

• Shared application ecosystem. Every editable resource has an identity, a kind, content, and a committed revision. Any edit declares the revision it was based on: if it matches the current revision, the change is accepted and the revision advances with a recorded actor and summary; if not, it is returned as a conflict and preserved for reconsideration. Main can let a Subagent prepare a private candidate that never becomes a shared edit until Main approves it. Native applications (documents, presentations, CAD, Blender) give agents domain operations plus change summaries that exclude their own edits; external software connects through MCP, where the application keeps its own ownership and concurrency semantics.

• Persistent state. Retained task state is decomposed into working objects and artifact references, progress/decisions/evidence, and ongoing executions with waiting conditions and pending feedback. Long computations run as background Jobs with persistent identities and logs. Source scripts monitor external state deterministically against a saved baseline, so unchanged observations cost no model calls. At phase boundaries Main updates a memory document before a context reset, and the context is reconstructed from that memory plus runtime state plus recent history, under a token budget. Completed turns are checkpointed so an interrupted Run can resume.

• Validation. Two evaluation tracks: (1) 12 general agent benchmarks plus 6 categories of real application scenarios, compared against mainstream cowork frameworks; (2) an RSI case study where CoworkOS analyzes model weaknesses, optimizes the data pipeline, synthesizes and validates post-training data, feeds it into training, and iterates the closed loop over five rounds — a workload that deliberately requires both complex productivity reasoning and long-running monitoring.

Why This Matters

Impact on research. The paper argues that models and their harnesses must co-evolve: the harness determines how a model acts and how well it uses available resources. By framing agent progress as three stages — Agent Workflow (reasoning/tool trajectories), Agent Assistant (persistent individual needs), and Agent Cowork (shared professional work on evolving artifacts) — it offers a design lens for moving from agent-driven automation toward sustained human–agent–environment collaboration. Its revision-based resource protocol and durable delegation state are concrete mechanisms others can build on, and the RSI study demonstrates an agent harness acting as an automated post-training loop rather than a single-shot task solver.

Real-world applications:

• Software and web production: frontend websites and games built through CLI execution, search, file operations, and MCP-connected tooling.
• Office and presentation work: editable text documents and slide decks that a person and an agent revise turn by turn in the same file.
• Design and 3D content: parametric CAD models refined through user instructions, agent updates, and direct human edits, plus Blender scenes where stable object identities allow targeted changes to a shared model.
• Long-running ML operations: monitoring multi-day training runs, retaining logs, and deciding when to intervene — the RSI case study is an instance of this.

Industry relevance. The comparison set is the commercial and open-source frontier of coding and work-environment agents — Claude Code, Codex, OpenHands, DeepSeek Harness, Kimi Code, ZCode, Qoder, Hermes Agent. CoworkOS's claim is that a single harness can serve both "deliver a hard artifact" and "stay on duty," which is what enterprise deployment of cowork agents actually requires. The MCP integration path matters commercially because it lets existing software keep ownership of its documents and concurrency semantics instead of being replaced.

Future Directions

• Toward "general cowork-agent intelligence." The authors explicitly frame CoworkOS as opening "a meaningful path" in this direction, leaving open how far the harness-plus-backbone combination scales.
• Deeper RSI loops. The five-round post-training study is presented as a case study; whether longer loops keep yielding gains, and where they saturate, is unresolved. Also open: how much of the 9.76-point gain comes from strategic decisions versus the data pipeline itself.
• Harness–model co-evolution. The paper states that models and harnesses need to co-evolve but only tests one backbone (GLM-5.3) in the RSI setting; how different backbones interact with the same harness is not reported.
• Human-in-the-loop at scale. The shared-application design lets humans intervene by editing the work itself, but the paper does not report measurements of how human participation patterns affect outcomes, nor how conflict handling behaves under heavy concurrent editing.

Target Audience

AI researchers and engineers building agent runtimes and harnesses; teams deploying cowork or coding agents in production who need long-horizon state management and human oversight; and practitioners working on automated post-training and self-improvement pipelines. Readers need comfort with agent architectures and context management — this is not an introductory paper. Product and platform architects evaluating MCP-based integrations for professional software (CAD, Blender, Office tooling) will also find the resource-protocol and revision-control design directly relevant.

Authors’ abstract

Rapid advances in cowork agents are shifting human-AI collaboration toward real-world automation, delivering software, designs, and other artifacts. However, such productivity work demands both high-quality delivery on complex productivity tasks and continued monitoring and decision-making over long horizons, a combination that remains an open challenge. We introduce CoworkOS, a general-purpose harness for long-horizon work that separates task strategy from execution management: the model decides actions, delegation, and acceptance, while the runtime maintains state and feedback. Its three-layer architecture enables direct execution or delegation to Subagents, synchronously or asynchronously, under stable responsibilities. Through a shared application layer, humans and agents inspect and revise the same evolving documents, presentations, CAD models, and Blender scenes, so human-in-the-loop participation can enter both through conversation and through direct modification of the work itself. To sustain continuity across agents and sessions, CoworkOS further introduces hierarchical workspaces and persistent semantic memory, so working files, key decisions, and long-running Job logs remain shareable, reusable, and resumable after interruption. Across 12 benchmarks and 6 categories of real-world applications, CoworkOS proves highly competitive with frontier agent applications such as Codex and DeepSeek Harness. As a sustained-work case study, CoworkOS uses GLM-5.3 as its backbone to conduct RSI-driven automated post-training on Qwen3.6-35B-A3B. Over five rounds, the model's average score across eight benchmarks rose from 33.19 to 42.95 (+9.76). Looking ahead, we believe CoworkOS opens a meaningful path toward general cowork-agent intelligence.