Astron Agent: iFlyTek's Open-Source Enterprise Multi-Agent Orchestration Platform Goes Apache 2.0
The bottom line: Astron Agent is iFlyTek’s open-source enterprise-grade agentic workflow platform — a full microservices architecture spanning 10+ services across Java, Python, Go, and TypeScript, with built-in RPA, MCP protocol support, and a visual low-code builder. Released under Apache 2.0 with 8,500+ GitHub stars and v1.0.8 as of May 29, 2026 [1], it’s one of the most complete open-source multi-agent orchestration platforms available.
Why Astron Agent Stands Out
Most multi-agent frameworks are single-process Python libraries — LangGraph, CrewAI, and AutoGen all run as code you import. Astron takes a fundamentally different approach: it’s a full platform you deploy, not a library you import. This means built-in multi-tenancy, authentication, persistent storage, async event-driven execution via Kafka, and enterprise-grade high availability out of the box (Kingy AI, 2026).
The platform was presented at MWC Barcelona 2026 and has hosted community hackathons and training cohorts in China, indicating real enterprise deployment experience behind the codebase (GitHub README, 2026).
Key Differentiators
- Polyglot microservices architecture — Each component uses the best language for the job: Java 21/Spring Boot for the API gateway, Python/FastAPI for agent runtime and workflow orchestration, Go/Fiber for high-throughput tenant management, React 18/TypeScript for the frontend (DeepWiki, 2026).
- Built-in intelligent RPA — The companion
astron-rpaproject (7,200+ GitHub stars) provides 300+ pre-built automation capabilities including desktop, web browser, Office document, and ERP system automation (GitHub, 2026). - Apache 2.0 with no commercial restrictions — No per-seat fees, no enterprise tiers, no vendor lock-in.
- MCP protocol support — Implements the Model Context Protocol as a tool integration layer via the
core-linkservice. - Visual low-code workflow builder — Drag-and-drop canvas using ReactFlow, with branching, loops, parallel execution, and human-in-the-loop checkpoints.
Architecture: The Microservices Breakdown
Astron Agent is deployed via Docker Compose with 12 core microservices communicating over a Docker bridge network. Here’s the full service matrix (DeepWiki, 2026):
| Service | Language | Port | Responsibility |
|---|---|---|---|
| nginx | Nginx 1.25 | 80 | Reverse proxy, static assets, SSE support |
| console-frontend | React 18 + Vite | 1881 | Visual workflow editor, agent config UI |
| console-hub | Spring Boot 3.x | 8080 | Bot management, publishing, CRUD APIs |
| casdoor | Go | 8000 | OAuth2/OIDC authentication, SSO |
| core-tenant | Go 1.21+ | 5052 | Multi-tenancy, API keys, quotas |
| core-database | Python/FastAPI | 7990 | Dynamic memory, conversation history |
| core-agent | Python/FastAPI | 17870 | Agent runtime, LLM orchestration, tool calling |
| core-workflow | Python/FastAPI | 7880 | Workflow engine, node execution, SSE streaming |
| core-knowledge | Python/FastAPI | 20010 | RAG pipeline, embeddings, semantic search |
| core-link | Python/FastAPI | 18888 | HTTP/MCP tool execution |
| core-rpa | Python/FastAPI | 17198 | RPA task creation and querying |
| core-aitools | Python/FastAPI | 18668 | TTS, OCR, translation, other AI features |
Infrastructure dependencies include Kafka 3.7.0 for async event-driven workflow execution, PostgreSQL and MySQL (database-per-service), Redis 7 for caching, and MinIO for S3-compatible storage.
Writing a Multi-Agent Workflow
The visual builder makes getting started fast. A typical workflow in the ReactFlow canvas includes:
- Start node — Triggers the workflow
- Large Model node — Select an LLM (SparkX 1.5, OpenAI, Azure OpenAI, or local models), set system prompt, and configure parameters
- Tool/Action node — Call pre-built tools (RPA actions, MCP tools, HTTP APIs)
- Condition node — Branch based on model output or field values
- Human-in-the-loop node — Pause for user approval or input
- Finish node — Return results
The “Model-of-Models” approach lets you assign different LLMs to different workflow steps — use a fast cheap model for simple classification and an expensive reasoning model for complex analysis, all within the same workflow (GitHub README, 2026).
Code Example: Deploying with Docker Compose
# Clone the repository
git clone https://github.com/iflytek/astron-agent.git
# Navigate to deployment directory
cd docker/astronAgent
# Copy and configure environment
cp .env.example .env
# Edit .env with your model API keys
# Start all services (including Casdoor auth)
docker compose -f docker-compose-with-auth.yaml up -dAfter deployment, access the platform at http://localhost/ and log in via Casdoor (default: admin / 123).
Multi-Agent Capabilities
Astron supports three agent types (Kingy AI, 2026):
- Chat agents — Conversational agents with multi-turn dialogue
- Chain-of-thought agents — Structured reasoning with intermediate steps
- Process agents — Multi-step workflow agents with branching and parallel execution
Agents share context through the core-database Memory DB Service, which handles both short-term session memory and long-term persisted context. The core-workflow service uses Kafka for async message passing between workflow nodes, enabling parallel agent execution and event-driven coordination.
RPA: The Secret Weapon
The astrom-rpa project is what sets Astron apart from Western frameworks. With 7,200+ GitHub stars and 300+ pre-built capabilities, it can:
- Automate Windows desktop applications natively
- Control web browsers (IE, Edge, Chrome)
- Process WPS/Office documents
- Interact with Chinese enterprise ERP systems (Kingdee, YonYou)
- Perform image recognition and PDF processing
- Send emails and make API calls
The bidirectional call architecture means agent workflows can invoke RPA tasks, and RPA workflows can call back into agent logic for decision-making.
How It Compares
| Dimension | Astron Agent | LangGraph | CrewAI | AutoGen |
|---|---|---|---|---|
| Deployment model | Docker Compose (platform) | pip install (library) | pip install (library) | pip install (library) |
| Infrastructure included | Kafka, MySQL, Redis, MinIO, auth | None | None | None |
| Multi-tenancy | Built-in (Go tenant service) | Manual | Manual | Manual |
| RPA | Native (300+ capabilities) | None | None | None |
| Low-code builder | Visual (ReactFlow) | LangGraph Studio | No | AutoGen Studio |
| License | Apache 2.0 | MIT | MIT | MIT (AG2: CC BY 2.0) |
| GitHub stars | 8,500+ | 99,000+ | 33,000+ | 54,000+ |
What’s clear is that Astron targets a different tier — it’s for organizations that want a full platform they can deploy and manage, not a library to build from scratch. For teams that already have infrastructure and need a lightweight wrapper, LangGraph or CrewAI are more appropriate.
Production Considerations
For production deployments, consider:
- Resource requirements — The full stack requires significant RAM (Redis, Kafka, MinIO, 10+ services). Start with 16GB+.
- Database design — Each microservice gets its own MySQL database, which is clean but adds operational overhead.
- Kafka tuning — The
core-workflowservice depends on Kafka for async execution. If you’re running a single-node setup, ensure Kafka is properly configured. - Model API keys — You’ll need API keys for the LLMs you intend to use. Local models via Ollama/vLLM are supported but require additional configuration.
- SSO integration — Casdoor handles auth natively, but can integrate with existing LDAP/OIDC providers.
The Bottom Line for Engineering Teams
Astron Agent is a serious contender for teams that need a full-platform multi-agent orchestration solution with enterprise features. The Apache 2.0 license, built-in RPA, visual workflow builder, and polyglot architecture make it particularly attractive for organizations in Asia or those working with Chinese enterprise systems.
For teams already invested in the LangChain or AutoGen ecosystem, the switching cost is high — Astron is a completely different architecture paradigm. But for greenfield deployments or organizations that want a turnkey multi-agent platform rather than a framework to build on, Astron Agent deserves a close look.
Related Reads
- The Agent Service Mesh: Production Patterns for Inter-Agent Communication and Governance — CodeIntel
- Hermes Agent Multi-Agent Setup Guide 2026: Run Specialized AI Agents — ToolBrain
- TauricResearch/TradingAgents Review 2026 — Multi-Agent LLM Trading Framework — ToolBrain
- Build Log: Multi-Agent Research Pipeline with OpenClaw — ToolBrain
References:
- GitHub Repository: https://github.com/iflytek/astron-agent
- DeepWiki Architecture Overview: https://deepwiki.com/iflytek/astron-agent/1-astron-agent-platform-overview
- Kingy AI Review by Curtis Pyke, May 18, 2026: https://kingy.ai/ai/astron-agent-review-iflyteks-open-source-enterprise-ai-workflow-platform-is-the-real-deal/
- Multi-Agent Orchestration Guide 2026, Hubstic: https://www.hubstic.com/resources/blog/multi-agent-orchestration-guide
