From “Chat Sessions” to “Always-On Digital Employees”: 5 Key Changes in the openJiuwen Hyper-Agent Architecture

Author’s note: This article explains the persistent-agent architecture behind openJiuwen Hyper-Agent, helping workflow builders decide whether the approach is a good fit for their teams.

The Huawei-backed open-source agent community openJiuwen has released the Hyper-Agent swarm architecture, taking agents beyond one-off chat sessions and into real work groups as “persistent digital employees”. On November 5, 2026, Pandaily reported on a community article published by IT Home, stating that these capabilities are available in openJiuwen WorkSwarm and that the code is open-sourced on GitHub under the name JiuwenSwarm.

This isn’t just another question-answering bot added to a group chat. The real change is a reversal of the relationship between agents and sessions: a session is no longer a container for an agent, but a resource the system can allocate.

Key takeaway: This article brings the individual features together into an architectural view, helping you understand what openJiuwen Hyper-Agent changes and what your team should verify before adopting it.

openJiuwen Hyper-Agent at a Glance

It’s worth noting that the facts in this article are based on a secondary report of a community article. The report doesn’t disclose the underlying model list, deployment requirements, license, or production readiness. You’ll need to check the GitHub repository and official documentation to verify those details.

How openJiuwen Hyper-Agent Turns Sessions into Resources

Most agent applications follow a “one session, one agent” model: a user opens a conversation, and the agent gets to work. Its identity, context, and task progress are all tied to that conversation. Switch to another group or window, and collaboration often has to start over.

Hyper-Agent takes the opposite approach. A Persistent Agent has its own identity and state, so it can continue receiving work. Sessions become underlying resources that the system allocates and schedules concurrently, with context restored when work resumes. According to the community, this design builds on earlier Persistent Session work, allowing one agent to track multiple tasks across multiple third-party group chats at once.

Illustration: On the left, state belongs to the session. On the right, it belongs to the agent. If you want to compare context overhead using your own business conversations, you can run a small-scale experiment through APIYI apiyi.com’s unified interface.

5 Key Components of the openJiuwen Hyper-Agent Architecture

Based on the available reporting, the system can be understood as five layers: access, orchestration, identity management, collaboration, and observability. The table below groups the components by architectural responsibility; it isn’t an official classification.

The Hyper-Agent Employee Center and Context Handoffs

In the Employee Center, users can configure responsibilities, working styles, delivery requirements, skills, connectors, knowledge sources, and even a dedicated email address. This expands prompt configuration into something like a job description, defining both the agent’s capabilities and its external identity.

Long-running work will inevitably run up against context window limits. WorkSwarm handles this by switching to a new window as the current one approaches its limit, carrying over a handoff summary with the goal, progress, and next steps. When it needs details, it retrieves them from archived history. This lets work continue without cramming the entire history into the current window.

Hyper-Agent Passive and Adaptive Modes

Deciding when an agent should speak in a work group chat is an unavoidable question for an always-on agent. WorkSwarm offers two response modes, which differ mainly in how predictable they are.

The report doesn’t explain exactly how adaptive mode makes decisions or how accurate it is. Teams can try a simplified experiment to get a feel for the challenges involved. The code below is just our demonstration, not WorkSwarm’s implementation:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

message = "接口今天下午还没联调通，明天的发布可能有风险。"
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "你是项目助理。只输出 ignore、respond 或 intervene。"},
        {"role": "user", "content": message}
    ]
)
print(response.choices[0].message.content)

import json
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

def create_handoff_summary(history: list[str], model: str = "gpt-4o-mini") -> dict:
    """Summarize work records into goals, progress, and next steps to simulate a context handoff."""
    prompt = (
        "请根据工作记录输出 JSON，字段为 goals、progress、next_steps。"
        "不要输出 JSON 以外的内容。\n\n" + "\n".join(history)
    )
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

records = [
    "产品经理：周五前完成客户周报。",
    "智能体：已汇总销售数据，等待客服数据。",
    "客服主管：今天下班前提供工单统计。"
]
print(create_handoff_summary(records))

Experiment tip: You can get free test credits through APIYI at apiyi.com, then compare how different models handle anonymized group chat samples. This tests the decision logic; it doesn’t mean WorkSwarm already supports this API.

Cross-Group and Local Collaboration with openJiuwen Hyper-Agent

The same agent can work across workplace apps such as Feishu and DingTalk—for example, receiving a request in one channel and delivering the result in another. Cross-group sharing isn’t allowed by default: users must check the source group, recipient, and content before granting one-time or permanent permission. They can also revoke permission later.

Team members can also run WorkSwarm on their own devices. Agents on cloud servers and personal computers can collaborate in the same group, using locally authorized files and tools. The cloud keeps agents online continuously, while local devices provide access to data and tools in each person’s environment.

For larger tasks, a SwarmEngine group chat can bring users, Persistent Agents, individual experts, and expert teams into the same space. An expert team has a lead who receives tasks, reports progress, and coordinates delivery, while team members work in the background. Experts can also come from third-party agents such as Codex and Claude Code and work alongside custom-built digital employees.

The Impact of openJiuwen Hyper-Agent

Impact on Developers and Workflow Builders

• A shift in design focus: From designing one-off conversations to designing agent identities, states, permissions, and handoff mechanisms.
• Greater operational demands: Persistent agents need to be monitored, audited, and managed like online services.
• Broader integration boundaries: IM, knowledge bases, email, and local tools may all become part of the same task workflow.

Impact on Team Collaboration

• Agents become collaborators, not just tools: They can follow tasks over time rather than simply respond to a single question.
• Governance comes earlier: Teams need to agree in advance on who can share data, when agents can speak, and who’s accountable for results.
• Mixed orchestration becomes a key consideration: How custom-built employees and third-party agents divide the work affects delivery quality and accountability.

Key Questions for Teams Evaluating Hyper-Agent

openJiuwen Hyper-Agent FAQ

openJiuwen Hyper-Agent: Key Takeaways

• Core architecture: Agents retain their identity and state, while sessions become schedulable resources.
• Core components: Gateway handles incoming connections; AgentServer schedules agents and sessions.
• Long-running operation: Handoff summaries support context switching, while archived history can be retrieved on demand.
• Response strategies: Passive mode offers more control; adaptive mode is more proactive but needs validation.
• Permissions: Sharing across groups requires approval. Authorization can be one-time or permanent, and it can be revoked.
• Hybrid collaboration: Cloud services, local devices, expert teams, and third-party agents can all join the same collaboration space.
• Validation path: First verify the project documentation, then use APIYI apiyi.com to test the model components.

Conclusion: Architectural Lessons from openJiuwen Hyper-Agent

What makes openJiuwen Hyper-Agent worth watching isn’t just that it brings agents into Feishu or DingTalk. It’s that it puts the idea of “turning sessions from containers into resources” into practice in its system design:

1. Persistent identity: A Persistent Agent no longer loses continuity when an individual session ends.
2. Scheduling takes center stage: AgentServer coordinates agents and multiple work sessions.
3. Governance determines real-world adoption: Permission approvals, controls over when agents speak, and usage monitoring determine whether the system can work for real teams.

If your work depends on collaboration across multiple groups, long-term follow-up, and delivery across channels, this approach is worth exploring further. If your workflows involve sensitive data or strict compliance requirements, start with an isolated pilot using passive mode and least-privilege access. For the model decision-making components, you can use APIYI apiyi.com to compare multiple models through the same interface and gather data for future technology decisions.

📚 References

1. Pandaily – openJiuwen’s Hyper-Agent Swarm Puts Persistent AI Agents Into Work Chats as Digital Employees: The primary source for this article’s facts
2. Link: pandaily.com/openjiuwen-hyper-agent-swarm-architecture-persistent-agents-workswarm-digital-employees
3. Notes: Covers the Hyper-Agent architecture, WorkSwarm features, and the community’s future plans. It’s a secondary report based on a community submission.

Author: APIYI Technical Team
Technical discussions: Contact us through the APIYI homepage. For more resources, visit the docs.apiyi.com documentation center.