Eigent

Eigent is an open-source cowork desktop application designed to build, manage, and deploy custom AI workforces. Key capabilities include:

• Single Agent Collaboration: Work with one dedicated agent for tasks like research, writing, or debugging.
• Workforce Collaboration: Scale to multiple specialized agents that work in parallel to execute complex, multi-step workflows.
• Automation: Schedule periodic workflows to run tasks automatically.
• Local & Secure: Run agents locally so files, credentials, and context remain under your control.
• Model Agnostic: Connect to any model, including cloud APIs, enterprise gateways, or local inference.
• MCP Integration: Supports Model Context Protocol integration.
• Built-in Tools: Includes a browser and terminal toolkit.

Eigent is a multi-agent workflow desktop application designed to build, manage, and deploy customized AI agent teams. It transforms complex workflows into automated tasks using the CAMEL-AI framework.

Key Capabilities

• Single Agent Collaboration: Work with a single focused agent for tasks like research, writing, or debugging.
• Multi-Agent Teamwork: Scale to multiple specialized agents that split work, collaborate in parallel, and execute multi-step workflows.
• Automation: Schedule periodic workflows to run tasks automatically.
• Model Agnostic: Connect to any model, including cloud APIs, enterprise gateways, or local inference (e.g., via Ollama).
• Local & Secure: Run agents locally to keep files, credentials, and context under your control.
• MCP Integration: Supports Model Context Protocol integration.

Eigent is an open-source Cowork desktop application designed to build, manage, and deploy custom AI workforces. It allows users to automate complex workflows through two primary modes:

• Single Agent: A focused agent for direct tasks like research, writing, or debugging.
• Workforce (Multi-Agent): Multiple specialized agents that collaborate in parallel to execute complex, multi-step workflows.

Key technical features include:

• Model Agnostic: Connect to cloud APIs, enterprise gateways, or local inference (e.g., Ollama).
• Automation: Schedule recurring workflows for autonomous task execution.
• MCP Integration: Support for Model Context Protocol.
• Toolkits: Built-in Browser and Terminal toolkits.

The skill-security-auditor is designed for security auditing of code, configurations, and infrastructure. It is triggered by terms such as "security audit", "vulnerability scan", "code review for security", "find secrets", "check for vulnerabilities", "OWASP", or "CVE".

Capabilities:

• Scan for vulnerabilities (SQL injection, XSS, command injection, path traversal).
• Detect hardcoded secrets and credentials.
• Review authentication and authorization.
• Check dependencies for known CVEs.
• Audit configuration files for insecure defaults.
• Generate structured security reports.

The Electron desktop client provides specialized functionality not available in web-based environments, including:

• WindowControls: UI for managing application windows.
• HardwareBridge: UI and logic for interacting with local hardware.
• IPC Handlers: Inter-Process Communication handlers for managing windows, file system access, and Chrome DevTools Protocol (CDP) interactions.

Eigent is an open-source desktop coworking application designed to build and manage personalized AI workforces. Key concepts include:

• Single Agent Harness: Execute focused tasks with a single dedicated agent (e.g., for research, writing, or debugging).
• Multi-Agent Workforce: Scale to multiple specialized agents that collaborate in parallel to execute complex, multi-step workflows.
• Automation: Schedule recurring workflows so agents can perform tasks autonomously.
• Model Agnostic: Connect to any model via cloud APIs, corporate gateways, or local inference (Ollama, etc.).
• MCP Integration: Supports Model Context Protocol for enhanced capabilities.

Eigent is built using the following technologies to ensure scalability and extensibility:

Backend

• Framework: FastAPI
• Package Manager: uv
• Async Server: Uvicorn
• Authentication: OAuth 2.0, Passlib
• Multi-Agent Framework: CAMEL

Frontend

• Framework: React
• Desktop Framework: Electron
• Language: TypeScript
• UI Libraries: Tailwind CSS, Radix UI, Lucide React, Framer Motion
• State Management: Zustand
• Flow Editor: React Flow

Slide Masters allow you to define a template (background, objects, placeholders) that can be reused across multiple slides.

1. Define the master using pres.defineSlideMaster({ title, background, objects }).
2. The objects array contains placeholders. A placeholder object looks like: { placeholder: { options: { name, type, x, y, w, h } } }.
3. Create a slide using that master with pres.addSlide({ masterName: "YOUR_MASTER_NAME" }).
4. Populate placeholders using slide.addText(text, { placeholder: "name" }).

pres.defineSlideMaster({
  title: 'TITLE_SLIDE', 
  background: { color: '283A5E' },
  objects: [{
    placeholder: { options: { name: 'title', type: 'title', x: 1, y: 2, w: 8, h: 2 } }
  }]
});

let titleSlide = pres.addSlide({ masterName: "TITLE_SLIDE" });
titleSlide.addText("My Title", { placeholder: "title" });

Every skill requires a SKILL.md file and can optionally include bundled resources. The directory structure should follow this pattern:

skill-name/
├── SKILL.md (required)
│   ├── YAML frontmatter metadata (required)
│   │   ├── name: (required)
│   │   ├── description: (required)
│   │   └── compatibility: (optional)
│   └── Markdown instructions (required)
└── Bundled Resources (optional)
    ├── scripts/          - Executable code (Python/Bash/etc.)
    ├── references/       - Documentation loaded into context as needed
    └── assets/           - Files used in output (templates, icons, etc.)

An effective skill bundles reusable resources to help the agent execute tasks without repeating work. Use the following directory structure:

• scripts/: Contains executable scripts (e.g., Python scripts) for repetitive tasks like rotate_pdf.py or query_database.py. Always test these scripts to ensure they work as expected.
• references/: Contains documentation, schemas, or knowledge bases that provide context (e.g., schema.md for database tables or workflows.md for multi-step processes).
• assets/: Contains static files, templates, or boilerplate (e.g., a hello-world/ React template or brand guidelines).

Note: Only include directories that are necessary for your specific skill. Delete the example files generated by init_skill.py if they are not relevant.

To provide Model Context Protocol (MCP) servers to the workforce during a benchmark, use the installed_mcp key within the env object of your benchmark JSON.

You can also use env_file to point to a separate file (e.g., .env) containing credentials. This keeps sensitive information out of the benchmark JSON and allows credentials to be injected into each MCP server's environment.

Example configuration in benchmark/dataset/<n>.json:

{
  "data": {
    "name": "1",
    "question": "List all Notion pages",
    "env": {
      "env_file": "benchmark/envs/1.env",
      "installed_mcp": {
        "mcpServers": {
          "notion": {
            "command": "npx",
            "args": ["@modelcontextprotocol/server-notion"]
          }
        }
      }
    }
  },
  "tests": {
    "checker": ["benchmark/checker/1.py"]
  }
}

Comment markers (<w:commentRangeStart> and <w:commentRangeEnd>) must be siblings of <w:r> elements and direct children of <w:p>. They must never be placed inside a <w:r> tag.

To reference a comment in the text, add a <w:commentReference> element inside a run (<w:r>) following the range markers.

<!-- Comment markers are direct children of w:p, never inside w:r -->
<w:commentRangeStart w:id="0"/>
<w:del w:id="1" w:author="Claude" w:date="2025-01-01T00:00:00Z">
  <w:r><w:delText>deleted</w:delText></w:r>
</w:del>
<w:r><w:t> more text</w:t></w:r>
<w:commentRangeEnd w:id="0"/>
<w:r><w:rPr><w:rStyle w:val="CommentReference"/></w:rPr><w:commentReference w:id="0"/></w:r>