"Claude Cowork Killed My Startup"

AI is no longer just something you operate and interact with. It's starting to become a coworker.

👦🏻 Author: Jingshan

🧑‍🎨 Design: NCon

In AI circles, there's a fear that everyone knows but nobody talks about: getting "Sherlocked."

The term originated in the Apple developer community: you pour your heart into building a solid third-party tool, then the next system update rolls around and Apple bakes the exact same feature into the OS — for free.

And just like that, your product is dead in the water commercially.

Yesterday, that exact "experience" befell a startup team building a multi-agent platform called Eigent.

The trigger was Anthropic's launch of Claude Cowork. It's an unambiguous signal: AI assistants are stepping out of the chat window and trying to become actual digital colleagues.

It can read local files directly, understand your work environment, even tidy up your Downloads folder while it's at it.

From a user standpoint, the productivity gains are huge. But from the other side, for startups building "AI automation agents," the pressure is hard to ignore.

So Guohao Li, CEO of Eigent — a team working the exact same angle — posted a self-deprecating tweet on X that blew up:

Claude Cowork just "killed" our startup, so we did the most rational thing: we open-sourced it.

In one day, that X post racked up over 6,000 likes and nearly 1 million views.

It also piqued our curiosity: what exactly is this project?

🚥

Here's our full breakdown.

Why did Claude Cowork and Eigent emerge?

To understand why Eigent's open-source move drew so much attention, you first need to grasp:

What Anthropic redefined with Claude Cowork.

First off, Claude Cowork is seen as a "Claude Code" for non-developers, covering a massive swath of everyday work scenarios. It extends that "write code" capability into a much broader range of execution contexts.

It has several defining characteristics:

[1] Task scenarios that require running continuously on your local machine (the key is sustained operation).

[2] No need to open a terminal or face code — tasks execute directly inside Cowork.

[3] Direct access to user-designated local folders, where Claude can read, edit, or create files.

[4] Browser Use: Cowork integrates external tools like Chrome, expanding Claude's capabilities.

[5] Users can queue multiple tasks, and Claude processes them simultaneously without waiting for one to finish before starting the next.

We dug up a few Eigent case studies. Let's take a look.

First, when Eigent receives your task, it automatically breaks it down and assigns subtasks to the appropriate agents. Then, these agents collaborate like team members within your desktop environment to get the job done.

For example, this task:

Research Claude's "Cowork" feature and write a comparison report pitting Claude Cowork against Eigent's multi-agent workflow.

Or this task, which mirrors one of Claude Cowork's crowd-pleasing demos — "clean up the desktop":

You'll notice it can take fairly vague prompts and methodically organize the entire desktop — even the messy, cluttered kind with files scattered everywhere — sorting everything into designated folders:

I found a video clip of this task in action and embedded it below.

Let's zoom in on the details. In the final task summary sidebar, Eigent organized 55 files plus various images, audio files, and more. The whole flow was pretty smooth:

So this combination of "multi-agent parallel execution + local permissions + browser use" closes the loop on a lot of everyday work scenarios.

For instance, you can have it access a local folder and sort your Downloads directory by file type. Or dump a few hundred receipt screenshots on it and let it generate a structured Excel expense sheet on its own.

If you step back, there's an easy-to-miss fact: Eigent and Claude Cowork aren't doing two different things.

Their goals are nearly identical: making AI into an executor that can directly介入工作流 [directly intervene in workflows].

What exactly is Eigent?

First, Eigent is an open-source project on GitHub.

Put simply, it's an open-source desktop app. What it does is use a multi-agent framework to transform those long, messy workflows that normally require hopping between several tools into tasks that can run automatically.

The GitHub repo link below has a very complete deployment guide:

https://github.com/eigent-ai/eigent?tab=readme-ov-file

Beyond that, Eigent's team was also among the earliest to ship a multi-agent framework (it's actually the same team behind CAMEL), and started exploring agent scaling laws back in early 2023. They've open-sourced several other projects totaling roughly 36k+ stars. Specific GitHub star counts can be found at these links:

https://github.com/camel-ai/camel

https://github.com/camel-ai/owl

https://github.com/camel-ai/oasis

Currently, the Eigent project itself has hit 4.1k stars:

It's fair to say that the "killed by a giant" narrative put Eigent on more people's radar. But what kept it from vanishing is still fundamentally technical.

We dissected the project carefully and found that the Eigent team trained its focus on: distributed systems.

This explains why Eigent's core architecture is called Workforce — under this architecture, AI is organized as a set of execution nodes that can be split, scheduled, and coordinated. Each node has a defined role and task, collaborating to complete complex workflows.

I found an architecture diagram the Eigent team published:

Eigent and CAMEL AI are the same team. Eigent's multi-agent architecture is built on top of the agent framework CAMEL developed earlier. The entire CAMEL Workforce System handles tasks that require multiple people or systems to cooperate.

The system automatically assigns tasks, manages progress, and ensures each step completes smoothly.

In Eigent's architecture, task execution is split across different layers:

[1] Task Manager

Responsible for understanding the user's overall goal, breaking fuzzy requirements into concrete, executable subtasks, and producing a comprehensive execution plan.

[2] Coordinator

Mainly handles scheduling and organization, task allocation, managing dependencies between tasks, and aggregating results once all tasks are complete.

[3] Worker Nodes

This layer focuses on concrete operations — searching for information, writing code, processing data or documents. Multiple worker nodes can operate simultaneously without interfering with each other.

This decomposition approach borrows from distributed systems: break complex tasks into smaller problems, then accelerate the whole process through parallel execution.

From a practical standpoint, the biggest change is efficiency gains.

Traditional single-agent setups typically advance tasks linearly: search first, then read, then organize, then output — each step dependent on the previous one.

Tools like Eigent, by contrast, operate more like parallel scheduling: while one node is retrieving materials, another is already building out the report framework, and a third might be generating draft copy or code scaffolding ahead of time.

The efficiency boost from parallel execution becomes especially pronounced in long-chain, complex tasks. While the magnitude varies by scenario, the core principle is clear: task efficiency depends heavily on how the system is organized, not just model capability.

In Google's developer community, Eigent is also considered a relatively well-suited multi-agent platform for leveraging Gemini 3.

In December 2025, Google for Developers published Real-World Agent Examples with Gemini 3, in which Eigent was selected as one of six official examples.

In Google's description, Eigent is defined as a local-first multi-agent platform, with emphasis on its real-world applications in enterprise browser automation (such as Salesforce workflows).

Similar endorsements abound. For instance, Hugging Face's co-founder gave the project a shout-out:

Coincidentally, four days ago the Eigent team released a project called SETA — a large-scale open-source terminal agent training RL environment — which also got likes from Andrej Karpathy, John Schulman, and others:

At the execution layer, Eigent doesn't stop at concepts.

It integrates a wide array of practical tools through MCP, supporting web operations, code execution, and common workplace platforms.

However, multi-agent systems all face one problem: coordination overhead.

To address this, Eigent introduces self-reflection and replanning mechanisms that automatically adjust course when tasks get stuck. At critical junctures, the system also provides human-in-the-loop interfaces, letting humans intervene in decisions to prevent things from going off the rails.

Beyond technical architecture, another key choice for Eigent is local-first.

Users can also bring their own API keys to plug different models into Eigent, not locked into any single model.

Many traditional agent products run in cloud environments. This model is genuinely convenient for personal use, but gets awkward in more sensitive scenarios.

Eigent's approach is relatively straightforward: it allows the system to run on the user's local or private environment, with swappable model capabilities.

Users can choose to continue using SGLang, cloud models, or switch to locally deployed open-source models — such as running DeepSeek via Ollama or vLLM.

Under this configuration, the system can even complete tasks offline.

So this entire technical architecture and flow holds up Eigent's functionality quite well.

Finally, a word on Eigent's open-source release: this time they're using the Apache 2.0 license, which essentially means the team has relinquished most restrictions on how the code can be used.

The code can be modified, commercialized, even repackaged and redistributed.

Let's wrap up.

If we place Claude Cowork and Eigent side by side, an interesting consensus emerges.

Despite their completely different backgrounds, they're both trying to solve the same core problem: the single AI agent bottleneck.

You can think of it like this: you hire a very smart intern, but if you assign them a complex task, they'll probably hit a wall and deliver an incomplete answer.

Because the task is too complex, with interdependent steps at every turn. The emergence of Eigent and Claude Cowork shows what multi-agent capabilities can offer in these scenarios.

🚥

So, shifting focus away from the dramatic "crushed by a giant" narrative, products like Claude Cowork and Eigent may reveal a broader consensus:

Over the past few years, we've witnessed AI's shift from "pure tool" to "intelligent assistant." But all these changes are merely the beginning of AI becoming "real labor."

AI is no longer just something you operate and interact with. It's starting to become a coworker.

If you want to see how far this open-source project can go, head to GitHub and give it a star, or download it and take it for a spin.

GitHub: https://github.com/eigent-ai/eigent

Website: https://www.eigent.ai/