Welcome to EvoFabric#

EvoFabric is a lightweight multi-agent (Multi-Agent) framework built on an asynchronous graph engine, with high flexibility. We are committed to providing developers with more intuitive and more free ways to help them design, build, and debug complex artificial intelligence applications.

The framework is centered around the core design concept of “Graph as Orchestration,” abstracting the agent system into three basic components: State (State), Node (Node), Edge (Edge).

Overview#

Unlike traditional serial or pipeline-based orchestration, EvoFabric employs a state-driven asynchronous graph execution engine, where each node only needs to focus on processing the input and output state changes, while the graph engine automatically handles scheduling, grouping, execution, and synchronization.

With the highly modular design and convenient registration mechanism, developers can not only use the standard modules provided by the system but also freely define new nodes, tools, memory units, state update logic, and more. Once custom modules are registered, they can seamlessly integrate into the graph engine just like built-in components.

EvoFabric’s core concept is: “state-driven, schema orchestration, evolvable intelligent agent ecosystem.”

It is not only a multi-agent runtime architecture, but also a platform supporting workflow generation and evolution.

Characteristics#

EvoFabric’s unique advantages lie in the design of the underlying graph engine and component scalability:

Intuitive State Diagram-Driven Engine
- Graph consists of state, nodes, edges, nodes receive the complete state and output the state increment.
- Edges not only connect nodes but also handle state transfer, filtering, and rewriting. Additionally, the conditional edges it supports can dynamically control data flow direction.
- Nodes can receive data from multiple upstream “edge groups” and support specifying different state merging strategies for each “edge group,” easily handling complex data aggregation scenarios.
Flexible, customizable state management
- All status fields must clearly declare type and update rules.
- Custom update logic only needs to define def function(old, new) -> updated and complete registration to seamlessly integrate into the graph engine.
Streaming Message Processing and Context-Aware
- Provide a context access interface, enabling nodes and tools to perceive node and tool invocation information within the graph during runtime.
- Supports registering custom stream_handler, freely controlling the processing and display of streaming messages.
Strict Pydantic Serialization System
- All components adhere to the Pydantic specification to enable serialization and deserialization.
- The graph can be exported as a configuration file and reloaded to run, ensuring the application’s portability.
- Native/custom components are automatically registered with the factory by inheriting the base class and exported along with the diagram.

Main Functions#

EvoFabric provides a set of out-of-the-box features to help you quickly start your project.

Core Engine:
- Automatically identify and execute four types of nodes: synchronous/asynchronous + streaming/non-streaming.
- Supports step-by-step debugging (Debug Mode), allowing you to debug complex long-chain workflows.
- Supports graph visualization, enabling you to easily view the connections in directed graphs.
Built-in Nodes and Components:
- AgentNode: A standardized agent node that integrates memory, tool calls, and large language model (LLM).
- UserNode: An interactive node that pauses graph execution and receives user messages.
- Multiple memory modules: including ChatMem (dialogue memory), RetrievalMem (retrieval memory), etc.
Powerful Tool System:
- Powerful tool management system, supports Python tools and MCP tools. Supports the management of the internal state of tools.
- Built-in Docker sandbox, securely execute third-party code.
Model and Data:
- Provides multiple Clients, supporting interaction with chat, embed, rerank, and other models.
- Equipped with a vector database management module, supporting persistent management of documents, memories, etc.
Multi-Agent Collaboration:
- Built-in Swarm mode, supports building complex systems where multiple agents (Agent) collaborate.
Advanced Workflow Generation:
- SOP to Workflow: Standard Operating Procedure (SOP) documents can be directly converted into executable EvoFabric workflow diagrams.
- Kernel Evolve: Capable of dynamic evolution and optimization of kernel code.

Why Choose EvoFabric#

Logical Visibility, Controllable Debugging: The graph structure visualizes agent logic, combined with Debug and visualization features, making the system’s operational paths and state changes clearly visible, bidding farewell to “black-box development”;
Highly Scalable: Modular registration mechanism and Pydantic specifications support rapid integration of custom nodes, tools, and memory modules, adapting to various business scenarios;
Natively Asynchronous, Excellent Performance: Built on Python asyncio, perfectly supports high concurrency and streaming responses, ensuring stable operation of large-scale multi-agent systems;
End-to-End Support: from graph construction, execution, debugging, to export, reload, deployment, providing an end-to-end toolchain to reduce development and operations costs;
Versatile Across Scenarios: Whether it’s the research scenario for rapid prototype validation or the engineering scenario for large-scale deployment, it can provide a solid foundation and flexible expansion points.

EvoFabric makes “agent orchestration” no longer a black box, but a visual, tunable, and evolvable system. It is the structured cornerstone for building the next-generation agent systems.