cft0808/edict

⭐ 15,681  ·  Python  ·  GitHub Repo

This project solves the lack of governance, observability, and intervention in multi-agent AI orchestration by implementing a 1,300-year-old imperial Chinese "Three Departments and Six Ministries" system. It stands out by enforcing mandatory quality review (封驳), providing a real-time Kanban dashboard with full audit trails, and enabling live task intervention and model switching—features absent in CrewAI, AutoGen, and MetaGPT.

ai-agents ai-orchestration autonomous-agents claude dashboard kanban llm multi-agent

1-Sentence Summary

Ancient Chinese governance meets modern AI orchestration with mandatory quality review and real-time observability.

🔥 Key Capabilities & USP

• Mandatory Quality Review (封驳): A dedicated agent reviews all plans before execution and can reject them, forcing rework. This solves the black-box execution problem where other frameworks (CrewAI, AutoGen) blindly trust agent outputs without a governance gate.
• Real-Time Kanban Dashboard (军机处看板): 10 functional panels including task Kanban, agent health monitoring, memorial archives, template library, model config, and skills management. This solves the observability gap—you can see exactly what each agent is doing, pause/cancel/resume tasks live.
• Full Audit Trails & Intervention: Complete task lifecycle tracking (奏折存档) with the ability to intervene mid-execution. This solves the accountability problem—every decision is logged, every task can be stopped or redirected.
• Hot-Swappable Model Configuration: Each of the 12 agents can switch LLM models on-the-fly from the dashboard (~5 second生效). This solves the vendor lock-in and experimentation friction—no redeployment needed to test different models per agent.
• 12 Specialized AI Agents: 11 business roles (Prince, Three Departments, Seven Ministries) plus a compatibility agent, each with independent workspace, skills, and model configuration. This solves the role ambiguity problem—agents have clear, non-overlapping responsibilities with a permission matrix.

USP: No other multi-agent framework enforces a mandatory quality review gate with full observability and live intervention. This is the only system that treats agent orchestration as a governed process, not a fire-and-forget pipeline.

Technical Architecture

Component	Technology	Notes
Backend	Python 3.9+ (stdlib only for server)	Zero external dependencies for core server
Frontend	React 18	Real-time dashboard with Kanban panels
Orchestration	OpenClaw-based	Strict state transition validation via kanban_update.py
Deployment	Docker / Shell scripts	One-command startup or manual install
Communication	Agent-to-agent messaging	Visibility settings + permission matrix
State Management	Strict state machine	Every agent transition is validated

Architectural highlights:

• Opinionated but deliberate: The "Three Departments and Six Ministries" structure is not a gimmick—it maps directly to real governance needs (review, execution, archives).
• State transition validation: Prevents invalid agent state changes, ensuring the system never enters an unrecoverable state.
• Independent agent workspaces: Each agent has its own skills, model config, and workspace—no shared mutable state.

Quick Start Guide

Docker (recommended):

docker run -p 7891:7891 cft0808/sansheng-demo

Manual installation:

git clone https://github.com/cft0808/edict.git
cd edict
chmod +x install.sh && ./install.sh

Start:

chmod +x start.sh && ./start.sh
# or separately:
bash scripts/run_loop.sh &
python3 dashboard/server.py

Production deployment (systemd):

sudo cp edict.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable edict
sudo systemctl start edict

Pros, Cons & Use Cases

Pros

• Unique governance layer: Mandatory quality review is a genuine innovation—no other framework has this.
• Full observability: Real-time Kanban dashboard with 10 panels gives you complete visibility into agent behavior.
• Live intervention: Pause, cancel, or resume tasks from the dashboard—critical for production workflows.
• Low deployment complexity: Docker one-liner gets you running in seconds.
• Hot-swappable models: Change LLM models per agent without redeployment.

Cons

• Requires OpenClaw: Not a standalone framework; you must adopt the OpenClaw ecosystem.
• Heavily opinionated architecture: The "Three Departments and Six Ministries" structure is not a general-purpose framework. If your workflow doesn't fit this model, you'll fight it.
• Cultural metaphor barrier: The Chinese imperial governance metaphor may be confusing or off-putting to non-Chinese users. Documentation and terminology assume familiarity with this system.

Who should NOT use this?

• Teams building simple, linear agent chains (single-agent or two-agent workflows). The overhead of 12 specialized agents and mandatory review is overkill.
• Users who want a general-purpose agent framework that they can reshape arbitrarily. This is a specific governance model, not a flexible toolkit.
• Non-Chinese teams without cultural context who may struggle with the terminology (三省六部, 封驳, 军机处) and the underlying design philosophy.
• Projects requiring minimal dependencies—OpenClaw is a hard requirement.

Ideal Use Cases

• Enterprise compliance workflows where every agent action must be logged, reviewed, and auditable.
• Multi-step document generation (contracts, reports, legal filings) where quality gates are mandatory before final output.
• Complex decision-making pipelines with human-in-the-loop oversight (e.g., loan approvals, medical triage, regulatory filings).
• Teams experimenting with agent governance models who want a proven, opinionated system rather than building from scratch.
• Production deployments where you need to monitor, pause, and redirect agent workflows in real-time.

Community & Activity

With 15,681 stars, this project has clearly struck a nerve. The community is responding to a genuine pain point—the lack of governance in multi-agent systems. The last update on 2026-05-10 shows active maintenance. The combination of a unique cultural metaphor, a real governance innovation (mandatory review), and a polished dashboard suggests a project that's not just a toy but a serious tool for production use. The Docker one-liner and systemd support indicate a focus on operational maturity. If you're building multi-agent systems that need to be accountable, observable, and controllable, this is worth a serious look.