LobeHub Supports Heterogeneous Agents: Run Claude Code and Codex Locally at the Same Time

Starting with version v2.1.56, LobeHub officially supports Heterogeneous Agents, meaning you can directly integrate and use Claude Code and Codex on the LobeHub desktop app without switching between different tools. As long as the CLI tools are installed locally, you just need to open LobeHub, click to add the corresponding assistants, and you can start working right away.

Although this looks like a simple integration, the underlying architectural design is worth noting. The LobeHub team calls it “Heterogeneous Agents.” Essentially, different Agent Harnesses share the same interface and context. This design not only solves the problem of switching tools but also lays a foundation for future multi-agent collaboration and task scheduling systems.

What Are Heterogeneous Agents

Since the LobeChat era, the LobeHub team has treated Agents as first-class citizens in the AI world. As early as version 0.x in 2023, they designed a left-side Agent List and a right-side Topic List — quite ahead of its time. With the explosion of Agents in 2024, the product evolved from LobeChat into LobeHub, but the Agent-centric philosophy has remained unchanged.

The core concept of Heterogeneous Agents is: different Agents can use different Harnesses (execution engines), but they share a unified interface and context. In the LobeHub ecosystem, you can create agents using their self-developed Mecha Harness, or external harnesses like Claude Code and Codex. However, the topic/thread/message system derived from the agent is completely consistent.

The benefits of this design are obvious. Business capabilities built around agents — such as agent groups and task systems — can reuse the same architecture. You don’t have to develop separate interaction logic for each agent type, nor manually synchronize contexts between tools.

Real-World Use Cases

LobeHub currently supports assigning tasks to Claude Code directly from the web app. Once you assign a task, the Claude Code agent launches its runtime in a sandbox to execute the task and automatically submits a PR after completion. The whole process is automated — you just create the task in LobeHub and wait for the result.

This workflow is particularly useful for developers. Previously, you might have had to:

1. Discuss requirements and solutions in LobeHub
2. Switch to Claude Code or Codex to modify code
3. Manually sync the results and context back to LobeHub
4. Continue discussion or adjustment

Now, all these steps can be done within a single interface. More importantly, all conversation history, task states, and execution logs exist within the same context, preventing loss of information during tool switching.

The Imagination Space of Agent Groups

The LobeHub team mentioned that the agent group feature is under development — enabling Codex, Claude Code, and LobeHub’s own agents to collaborate. This direction is quite exciting.

Currently, most AI coding tools operate as single-agent systems. Cursor, Windsurf, Claude Code, and Codex each have their strengths, but they work independently. If you want Claude Code to handle architecture design, Codex to handle implementation, and LobeHub’s agent to do code review, you have to manually coordinate these tools.

The architecture of Heterogeneous Agents makes multi-agent collaboration possible. In theory, you could:

• Assign different types of tasks to different agents (design, implementation, testing, documentation)
• Dynamically choose the best agent based on task complexity
• Run multiple agents in parallel to increase efficiency
• Pass context and intermediate results between agents

Of course, implementing these scenarios requires solving challenges like task decomposition, inter-agent communication, and conflict handling. But at least on the architectural level, LobeHub has laid the groundwork.

Technical Implementation Considerations

The LobeHub team revealed they had the idea for Heterogeneous Agents back in August last year, but didn’t proceed until they had their own Agent Harness. It wouldn’t have made much sense to simply integrate external tools without that foundation.

This was a rational decision. Simple integrations wouldn’t offer substantial improvements in user experience — and might introduce compatibility issues. Only once you have your own agent implementation and understand the core abstractions can you design a genuinely universal architecture.

From a technical point of view, implementing Heterogeneous Agents requires solving several key issues:

1. Unified Interface Abstraction

Different agent tools have different APIs and interaction patterns. The CLI interfaces, parameter formats, and return types of Claude Code and Codex differ. LobeHub needs to define a unified interface that abstracts away these discrepancies.

The interface must be generic enough to cover most agent capabilities but flexible enough to expose each agent’s unique features. It’s a classic abstraction-layer design problem: done well, it dramatically reduces integration costs; done poorly, it limits agent functionality.

2. Context Management

Shared context among multiple agents is the core value of Heterogeneous Agents — but synchronizing and managing context isn’t easy.

The first issue is granularity. Should the entire conversation history be shared, or just specific topics/threads? Too coarse a granularity introduces irrelevant information; too fine risks losing important background.

The second issue is format. Different agents interpret context differently. For instance, Claude Code may prioritize code-related context, whereas LobeHub’s general-purpose agent may need dialogue history. Balancing standardization and customization is challenging.

3. Execution Environment Isolation

Different agents may conflict when sharing execution environments. Since Claude Code and Codex both need local filesystem access, concurrent modifications to the same file could cause problems.

LobeHub mentions Claude Code agents run inside sandboxes — a good practice. But sandbox implementation involves nuances like filesystem mapping, network access control, and resource limitations.

Comparison with Competitors

Currently, no other product offers this type of functionality. AI IDEs like Cursor and Windsurf still operate in single-agent mode. Although they’re exploring multi-agent models, those are limited to their ecosystems — not open to external agents.

Replit’s Agent model is also closed; powerful, but restricted to Replit-provided agents.

LobeHub’s Heterogeneous Agent architecture is more open. It doesn’t attempt to replace Claude Code or Codex but integrates them into a unified workflow. This approach better aligns with developers’ real needs — most use multiple tools based on tasks.

Of course, openness adds complexity. LobeHub must keep up with external updates, handle edge cases, and manage higher maintenance costs. But when done well, user engagement strengthens — because LobeHub becomes a platform, not just a tool.

Future Possibilities

The Heterogeneous Agent architecture opens up numerous possibilities for LobeHub:

1. Integration of More Agents

Beyond Claude Code and Codex, it could integrate more types of agents, such as:

• Testing agents (e.g. AI helpers for Playwright, Cypress)
• Documentation agents (e.g. Mintlify, GitBook AI tools)
• DevOps agents (e.g. AI assistants for Kubernetes, Terraform)

Each domain has specialized tools; integrating them into one platform would spare developers tool-switching hassles.

2. Agent Marketplace

LobeHub already has an Agent Marketplace, currently featuring Mecha Harness-based agents. Once the Heterogeneous Agent architecture matures, it could open up to third-party developers, allowing them to connect their own agents.

This forms an ecosystem: users discover different specialized agents within LobeHub; developers reach more users through LobeHub. Similar to VS Code’s plugin market — but even more advanced, as agents can collaborate.

3. Enterprise-Level Agent Orchestration

For enterprises, agent orchestration is essential. Complex software projects often require multiple agents for requirements analysis, architecture design, coding, testing, deployment, and monitoring.

If LobeHub can provide an orchestration framework allowing enterprises to define their workflows, assign tasks to appropriate agents, and set inter-agent dependencies, it could solve real-world challenges.

This direction would compete with frameworks like LangChain and LlamaIndex, but LobeHub’s advantage lies in its complete user interface, which lowers the barrier to entry.

Current Limitations

Despite its bright future, Heterogeneous Agents currently face a few limitations:

1. Desktop-only support: This feature works only on desktop, since it relies on local CLI tools. The web version can assign tasks, but execution happens locally. This limits teamwork use cases.
2. Agent group development ongoing: Multi-agent collaboration — the core value — is still under development. At present, agents can only work individually.
3. Limited agent types supported: Only Claude Code and Codex are supported so far. The architecture is generic, but adapting each tool takes time.
4. Incomplete context synchronization: It’s unclear how fully context sync works between agents — for example, whether Claude Code’s intermediate execution states are synced back into LobeHub. These details affect usability.

Significance for Developers

What does Heterogeneous Agent mean for developers? The most direct benefit is reduced tool switching. If you already use LobeHub, Claude Code, and Codex, now you can complete most tasks within one interface.

A deeper benefit is workflow integration. Previously, you might:

• Discuss design in LobeHub
• Implement code in Claude Code
• Refactor in Codex
• Submit PRs on GitHub
• Go back to LobeHub to discuss

Each step required manual actions and context syncing. Now these steps can be automated — even parallelized.

For teams, Heterogeneous Agents can improve collaboration. If team members use different agent tools, it’s been hard to share context and progress. With LobeHub, everyone can view the same agent’s execution history and understand each other’s work.

Insights for Tech Stack Choices

LobeHub’s Heterogeneous Agent architecture offers several insights for technology selection:

1. Value of abstraction layers: In fast-changing AI tool ecosystems, tightly binding to one tool increases costs. Abstraction layers reduce tool dependency and preserve flexibility.
2. Open vs closed systems: Closed systems provide smoother experiences but limit choice. Open systems are more flexible but more complex. LobeHub’s choice of openness is the right direction for developer tools.
3. Progressive implementation: The full vision for Heterogeneous Agents is ambitious, but LobeHub is approaching it progressively — first basic integration, then agent groups, then orchestration systems. This stable pace allows adjustment based on user feedback.

Summary

LobeHub v2.1.56’s Heterogeneous Agent feature is an interesting experiment. It’s not just tool integration — it’s architecturally preparing for multi-agent collaboration. The current functionality is basic, but the direction is promising.

For developers, its value depends on your workflow. If you already use LobeHub, Claude Code, and Codex, it can noticeably improve productivity. If you use only one, the benefit is smaller.

More importantly, LobeHub’s product philosophy stands out. Rather than building an all-in-one AI IDE, it’s building an agent platform that integrates specialized tools. This positioning is clear and aligns well with developers’ real needs.

The next milestone to watch will be the implementation of agent group collaboration. If LobeHub achieves effective multi-agent orchestration, it will evolve beyond an integration platform into a true agent coordination system — significantly amplifying its value.

References

• LobeHub v2.1.56 officially supports Hetero Agents - Detailed introduction by the LobeHub team on Linux.do community, including design ideas and future plans for Heterogeneous Agents
• LobeHub Changelog - Official LobeHub changelog documenting v2.1.56 and related feature updates