JoyAgent-JDGenie: An Open-Source Multi-Agent System for Direct Report Generation

JoyAgent-JDGenie is not merely another SDK masquerading as a complete solution. Most "AI agent" projects today offer little more than a collection of scattered building blocks. They provide a framework and a few API wrappers, leaving the developer to spend days stitching the components together. JoyAgent-JDGenie takes a different approach. It is a fully realized, open-source product built to solve the "last mile" problem in multi-agent applications. Instead of providing a platform to build a tool, it is the tool itself: you input a query or a task, and it produces a finished report, a slide deck, or a data visualization. No manual assembly is required.

The performance metrics support this claim. On the GAIA benchmark—a rigorous evaluation of real-world assistant capabilities—JoyAgent-JDGenie achieved a 75.15% accuracy rate. This score places it ahead of several prominent industry competitors with significantly larger marketing budgets. Crucially, it achieves these results without relying on a proprietary cloud ecosystem. You retain full ownership of the software stack and your data.

How It Functions

The system is delivered as a complete package including a frontend, backend, execution engine, and a set of specialized sub-agents. It is designed for flexibility, allowing you to integrate custom tools and agents without modifying the core architecture. Internally, it utilizes a hybrid planning approach: a high-level "work" mode and a granular "task" mode. The system dynamically toggles between plan & executor logic and react loops based on the requirements of the task. It also features a cross-task memory layer; if you request an analysis of Q1 sales one day and a Q2 report the next, the agent retains the relevant structure and context from the previous interaction.

A particularly notable feature is tool evolution through atomic disassembly and reassembly. Rather than forcing the model to generate an entirely new tool from scratch—which often results in unreliable outputs—the system breaks existing tools into atomic components and recombines them. This method significantly improves both execution speed and output accuracy.

The underlying Directed Acyclic Graph (DAG) execution engine manages high-concurrency tasks efficiently. Outputs are provided via real-time streaming, with final deliverables available in HTML, PPT, or Markdown formats.

Real-World Use Cases

Southeast Asia E-commerce Strategy: A user requested a presentation based on a cross-border e-commerce report. The system autonomously researched 2024 policy updates and competitive data within Southeast Asia, then utilized its report_tool to generate a comprehensive slide deck. The final output detailed localization tactics, AI-driven personalization, and KOL partnership strategies. It incorporated demographic data—such as the region's 610 million residents and high spending potential—transforming raw information into professional, board-ready guidance.

Feishu vs. WeCom vs. Slack: When tasked with comparing project management features for cross-team workflows, JoyAgent-JDGenie analyzed existing comparison reports and identified a lack of data regarding regional compliance. It performed targeted searches for recent updates and generated an updated HTML report featuring a new section titled "Domestic vs. International Market Support," reorganizing the document for better clarity.

Supermarket Sales Analysis: In response to a request to analyze store performance, the system generated four CSV files categorized by different statistical dimensions. It then processed this data using its internal code tools to produce a functional HTML dashboard complete with interactive charts.

Travel Planning: For a "7-Day Xinjiang Trip from Beijing," the system drafted a detailed July itinerary. It retrieved specific train schedules (such as the Z69 and Z179 routes), suggested regional highlights in Urumqi, Turpan, and Ili, and formatted the entire plan into a structured HTML travel guide.

Market Positioning

The current open-source agent ecosystem generally splits into three categories:

• SDKs: Examples include SpringAI-Alibaba and Coze. These offer partial access but often require a specific cloud environment to function.
• Frameworks: Examples include Dify, OpenManus, Owl, and n8n. These provide the scaffolding, but the user is responsible for building the actual application logic.
• Protocols: Standards like MCP and A2A are vital for interoperability but do not constitute a finished product.

JoyAgent-JDGenie stands out as a genuine "Product." It is an end-to-end, open-source solution that remains independent of specific ecosystems.

The benchmark data confirms its competitive standing. With a 75.15% GAIA score, it follows closely behind academic and high-end projects like Princeton's Alita v2.1 (87.27%) and Skywork (82.42%), while outperforming offerings from DeepMind, CAMEL, Hugging Face, and Huawei. For a production-ready open-source tool, this is a formidable position.

Technical Architecture

The architecture is organized into three distinct layers:

1. Agent Layer: Contains the primary agent and specialized sub-agents such as ReportAgent and CodeAgent.
2. Model/Tool Layer: Supports various LLMs (including DeepSeek V3 and GPT-4) alongside NLP and reporting utilities.
3. Memory Layer: Tracks session histories and task-specific context to ensure continuity.

Key features highlighted by the development team include:

• A complete, out-of-the-box product that supports extensive customization.
• Multi-pattern reasoning capabilities.
• Persistent memory across different tasks and workflows.
• High-concurrency execution via a DAG engine.
• A plug-and-play architecture for sub-agents and tools.
• Support for multiple output formats and full-streamed responses.

Getting Started

There are two primary methods for deployment.

Option 1: Using Docker

git clone https://github.com/jd-opensource/joyagent-jdgenie.git
cd genie-tool
# Configure your tools in .env_template
cd ..
docker build -t genie:latest .
docker run -d -p 3000:3000 -p 8080:8080 -p 1601:1601 -e OPENAI_BASE_URL="" -e OPENAI_API_KEY="" --name genie-app genie:latest

Option 2: Manual Installation This method requires JDK 17 and Python 3.11.

pip install uv
cd genie-tool
uv sync
source .venv/bin/activate
sh check_dep_port.sh   # Validates dependencies and checks for port conflicts
sh Genie_start.sh      # Starts all system services

Customization

Adding an MCP tool: Navigate to genie-backend/src/main/resources/application.yml, add your MCP server URLs to the mcp_server_url field, and restart the service.

Integrating a custom sub-agent: Implement the BaseTool interface as follows:

public class WeatherTool implements BaseTool {
    @Override public String getName() { return "agent_weather"; }
    @Override public String getDescription() { return "This is an agent for weather queries"; }
    @Override public Map<String, Object> toParams() { /* Define JSON schema */ }
    @Override public Object execute(Object input) { return "The weather today is clear"; }
}

Register the new tool in GenieController#buildToolCollection and restart.

Summary

JoyAgent-JDGenie fulfills the promise that many agent projects fail to meet: it provides a functional system that takes natural language instructions and returns high-quality, finished work. It performs exceptionally well on the GAIA benchmark, runs on local infrastructure, and does not require learning a proprietary language for extensions. For those seeking an alternative to fragmented configurations and cloud-dependent workflows, JoyAgent-JDGenie is a compelling solution.