Eigent Meets MiniMax M2.1

In real enterprise environments, many internal tools, dashboards, and legacy systems operate entirely in the browser. To automate these systems, we use Eigent, an open-source multi-agent workforce application that runs locally and can be fully set up from source, with a strong focus on browser automation — effectively acting as an Eigent open source cowork that sits on your own infrastructure.

In this post, we explore how Eigent leverages CAMEL Workforce and browser automation to handle complex, multi-step enterprise tasks. We also take a closer look at MiniMax M2.1, analyzing its performance on a realistic enterprise workflow and the architectural features that enable it to operate effectively in long-horizon, agentic browser automation scenarios.

Background: What is Eigent and how it supports MiniMax M2.1

Eigent is an open-source, multi-agent workforce product that runs on your desktop. It is built with a multi-agent workforce architecture, supported by general abilities such as browser automation, terminal automation, and MCPs. This design enables agents in Eigent to perform tasks much like human workers, operating in real desktop environments without deep API integrations or constant workflow reconfiguration.

As foundation models continue to advance, integrating them with Eigent's open-source multi-agent system allows developers and enterprise users to apply LLM capabilities directly to real-world use cases quickly and effectively. You can navigate to the Model Settings page in Eigent, locate the OpenAI Compatible section, and input your API key and URL. Once the model name is set to MiniMax-M2.1, you are ready to begin. Need help? See our guide on configuring your MiniMax API key: https://platform.minimaxi.com/docs/api-reference/text-openai-api.

GitHub repository and how to set up Eigent

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

Quick start: you can run Eigent using the pre-compiled desktop app for immediate usage, or set up the development environment to inspect the code and customize the agents.

Option A: The zero-config desktop app

1. Download the client from https://www.eigent.ai/.
2. Install the .dmg (macOS) or .exe (Windows).
3. Launch the app and the local backend starts automatically.

Option B: Developer setup

1. Prerequisites: Node.js (v18-22) and Python.
2. Clone and install:

git clone https://github.com/eigent-ai/eigent.git
cd eigent
npm install

3. Run the application:

npm run dev

Once running, you can configure your LLM providers (MiniMax M2.1, and others) directly in the settings. For more detailed information on configuration, advanced features, and troubleshooting, see the official documentation: https://docs.eigent.ai/get_started/welcome.

Under the hood: Eigent full stack and CAMEL Workforce architecture

Eigent system overview

Eigent is a local-first desktop application with multi-agent orchestration, powered by CAMEL Workforce as its core engine. The system implements a decoupled, full-stack architecture that operates entirely on the user's local infrastructure. This design ensures data sovereignty and avoids privacy risks associated with cloud-resident agent execution.

The frontend

The user interface serves as the control plane for agent configuration and workflow monitoring. It is built on React and TypeScript within an Electron framework.

Key components include:

• State management: Zustand handles transient state with efficient reactivity.
• Visual orchestration: React Flow visualizes the agent workspace and real-time execution.
• Communication: The frontend communicates with the backend via secure local HTTP requests.

The backend

The core logic resides in a local Python server using FastAPI and Uvicorn, which hosts the CAMEL multi-agent framework.

• Runtime environment: The backend runs on Python 3.10+ and is managed by uv for high-performance dependency resolution and environment isolation.
• Persistence layer: PostgreSQL, via SQLModel and SQLAlchemy ORM, stores audit logs, workflow history, and agent states.
• Multi-agent system framework: CAMEL handles orchestration logic (for example, workforce), interfacing with LLMs whether remote (for example, MiniMax) or local (for example, vLLM). CAMEL also provides toolkits such as browser, terminal, and document generation tools.

CAMEL Workforce: A multi-agent system inspired by organizational structures

At the heart of Eigent lies CAMEL Workforce, a multi-agent system architected to resolve complex, real-world tasks through decentralized cooperation. The system uses a strict producer-consumer pattern, mediated by an asynchronous message channel to manage dependency graphs efficiently.

Agent roles

• Coordinator agent: Functions as the primary dispatcher, maintaining global state and allocating subtasks based on availability and capability.
• Task agent: Responsible for semantic decomposition of high-level objectives into executable, atomic units.
• Worker agent: Executes atomic subtasks using domain-specific tools.

Asynchronous communication: The TaskChannel

Decoupling between the coordination layer and the execution layer is achieved via the TaskChannel. This asynchronous message queue manages task distribution without blocking the main execution thread.

Execution flow:

1. Workforce initiates a task.
2. Worker nodes poll for assignments.
3. Upon completion, results are pushed back.

Dynamic DAG construction

Enterprise workflows are rarely linear. CAMEL Workforce implements a dynamic directed acyclic graph (DAG) construction mechanism. When a high-level prompt is received (for example, "Create travel plan"), the Task agent decomposes this objective into discrete nodes.

The system maps dependencies, allowing the scheduler to:

• Execute independent nodes in parallel (for example, "Search flight ticket" and "Search hotel" run concurrently).
• Block dependent nodes until their predecessors reach a DONE state.

Fault-tolerant mechanisms

Given the non-deterministic nature of LLMs, Eigent treats failures as expected state transitions rather than fatal exceptions. The architecture implements a recovery mechanism using:

• Retry: Re-executes the sub-task on the same worker to handle transient errors.
• Replan: The Task agent modifies the original sub-task based on the failure log before re-queueing the sub-task.
• Reassign: The sub-task is migrated to a different worker with a compatible skill set.
• Decompose: If a task fails due to complexity, it is broken down into smaller subtasks.

Browser automation architecture in Eigent

Multi-agent automation only unlocks real enterprise value when paired with strong general-purpose capabilities such as browser automation. Eigent adopts a two-layer architecture that separates browser control from agent orchestration:

• The TypeScript layer handles browser interactions. It leverages native Playwright APIs to perform DOM operations, capture structured snapshots, generate SoM screenshots, detect occlusions, and handle advanced browser logic directly within the JavaScript runtime. Because Playwright is native to TypeScript, this layer gains access to features like _snapshotForAI() and improves performance and reliability.
• The Python layer handles AI orchestration. It manages LLM calls, agent decision-making, and task planning.
• The two layers communicate asynchronously via WebSocket, enabling non-blocking operations. Python sends browser operation requests, TypeScript executes them, and results are returned to the agent loop.

This architecture improves performance, enhances the precision of element interactions, and enables advanced capabilities like dynamic DOM filtering, viewport-aware snapshots, and in-browser SoM rendering. By delegating browser tasks to the native execution context, Eigent ensures a robust foundation for agent-based enterprise automation.

Testing MiniMax M2.1 on real-world enterprise tasks

We tested Eigent with MiniMax M2.1 to automate sales processes using Eigent's browser automation capabilities. The agent tasks covered real-world sales cycle stages, including lead capture and creation, qualification and pipeline management, quotation, negotiation, closing, and product management.

Across experimental runs, MiniMax M2.1 consistently showed three strengths:

1. Handles complex page structures well, including iframes and nested elements.
2. Checks its own actions to stay accurate and keep steps short.
3. Uses tools efficiently and flexibly, avoiding unnecessary steps.

Task:

"We have a new contact at Global Media - Jennifer Martinez (jennifer.m@globalmedia.com) is their new Senior Marketing Manager. Add her to our Salesforce and make sure she is connected to the right company."

In this task, MiniMax M2.1 operated within a complex Salesforce interface to add a new contact, Jennifer Martinez (Senior Marketing Manager), to Global Media and ensure she was correctly associated with the right account. This required navigating multiple UI layers, identifying the correct entry points, creating the contact, populating key fields, and validating the account linkage.

The results show that MiniMax M2.1 executed every step accurately without mis-clicks or workflow breakdowns. This demonstrates the model's strong capability in understanding complex enterprise UIs, planning multi-step actions, and reliably executing end-to-end tasks.

How MiniMax M2.1 improves task performance

MiniMax M2.1 is a strong choice for autonomous enterprise agents. It handles long-horizon, multi-step tasks with reliability and delivers a balance of performance, efficiency, and versatility.

Enhanced reasoning and workflow continuity

Compared to its predecessor, M2.1 produces more concise and efficient reasoning chains, improved responsiveness, and reduced token consumption. It is designed for better context management across multiple steps, helping maintain logical continuity during function calls and reducing the chance of errors later in the workflow.

Agent and tool generalization capabilities

M2.1 performs well across a variety of agent scaffolding frameworks and tooling environments. It generalizes reliably with different tools and supports integrated workflows, making it practical for enterprise automation.

Robustness in long-horizon planning

Enterprise automation often involves uncertainty, such as dynamic UI states, load delays, and unexpected interactions. Through improved reasoning and execution efficiency, M2.1 demonstrates resilience in longer task sequences.

Explore Eigent and MiniMax M2.1

Eigent is fully open-source, and we invite developers, researchers, and enterprise teams to explore, extend, and contribute:

• GitHub: https://github.com/eigent-ai/eigent
• Hugging Face: https://huggingface.co/MiniMaxAI/MiniMax-M2.1
• Discord: https://discord.camel-ai.org/