Paper deep dive
MASFactory: A Graph-centric Framework for Orchestrating LLM-Based Multi-Agent Systems with Vibe Graphing
Yang Liu, Jinxuan Cai, Yishen Li, Qi Meng, Zedi Liu, Xin Li, Chen Qian, Chuan Shi, Cheng Yang
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 3/13/2026, 12:15:25 AM
Summary
MASFactory is a graph-centric framework designed to simplify the orchestration of LLM-based multi-agent systems (MAS). It introduces 'Vibe Graphing,' a human-in-the-loop process that compiles natural-language intent into executable directed computation graphs. The framework features reusable components, pluggable context adapters for heterogeneous sources, and a visualizer for topology and runtime tracing, significantly reducing engineering effort compared to manual implementation.
Entities (5)
Relation Signals (4)
MASFactory â implements â Vibe Graphing
confidence 100% · MASFactory introduces Vibe Graphing, a human-in-the-loop approach
Node â connectedby â Edge
confidence 95% · MASFactory models collaboration as a directed graph composed of Node and Edge
Vibe Graphing â generates â Executable Graph
confidence 95% · compiles natural-language intent into an editable workflow specification and then into an executable graph
MASFactory â utilizes â Context Adapter
confidence 95% · MASFactory improves interoperability via Context Adapter
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large language model-based (LLM-based) multi-agent systems (MAS) are increasingly used to extend agentic problem solving via role specialization and collaboration. MAS workflows can be naturally modeled as directed computation graphs, where nodes execute agents/sub-workflows and edges encode dependencies and message passing. However, implementing complex graph workflows in current frameworks still requires substantial manual effort, offers limited reuse, and makes it difficult to integrate heterogeneous external context sources. To overcome these limitations, we present MASFactory, a graph-centric framework for orchestrating LLM-based MAS. It introduces Vibe Graphing, a human-in-the-loop approach that compiles natural-language intent into an editable workflow specification and then into an executable graph. In addition, the framework provides reusable components and pluggable context integration, as well as a visualizer for topology preview, runtime tracing, and human-in-the-loop interaction. We evaluate MASFactory on seven public benchmarks, validating both reproduction consistency for representative MAS methods and the effectiveness of Vibe Graphing. Our code (this https URL) and video (this https URL) are publicly available.
Tags
Links
- Source: https://arxiv.org/abs/2603.06007v1
- Canonical: https://arxiv.org/abs/2603.06007v1
Trouble viewing inline? Open PDF directly â
Full Text
36,395 characters extracted from source content.
Expand or collapse full text
MASFactory: A Graph-centric Framework for Orchestrating LLM-Based Multi-Agent Systems with Vibe Graphing Yang Liu 1 , Jinxuan Cai 1 , Yishen Li 1 , Qi Meng 1 , Zedi Liu 1 , Xin Li 1 , Chen Qian 2 , Chuan Shi 1 and Cheng Yang 1 * 1 Beijing University of Posts and Telecommunications 2 Shanghai Jiao Tong University liuyang1999, yangcheng@bupt.edu.cn Abstract Large language model-based (LLM-based) multi-agent systems (MAS) are increasingly used to extend agentic problem solving via role specialization and collaboration. MAS workflows can be naturally modeled as di- rected computation graphs, where nodes ex- ecute agents/sub-workflows and edges encode dependencies and message passing. However, implementing complex graph workflows in cur- rent frameworks still requires substantial man- ual effort, offers limited reuse, and makes it dif- ficult to integrate heterogeneous external con- text sources. To overcome these limitations, we present MASFactory, a graph-centric frame- work for orchestrating LLM-based MAS. It in- troduces Vibe Graphing, a human-in-the-loop approach that compiles natural-language intent into an editable workflow specification and then into an executable graph. In addition, the frame- work provides reusable components and plug- gable context integration, as well as a visual- izer for topology preview, runtime tracing, and human-in-the-loop interaction. We evaluate MASFactory on seven public benchmarks, vali- dating both reproduction consistency for repre- sentative MAS methods and the effectiveness of Vibe Graphing. Our code 1 and video 2 are publicly available. 1 Introduction With the introduction of tool use and feedback- driven correction, large language models (LLMs) are often packaged as agents that follow a perceptionâreasoningâaction loop, enabling long- horizon task execution in external environ- ments (Yao et al., 2023; Schick et al., 2023; Shinn et al., 2023). As tasks grow in complexity, a single agent often struggles to simultaneously * Corresponding author. 1 https://github.com/BUPT-GAMMA/MASFactory .Li- censed under Apache-2.0; use, modification, and distribution are permitted within its terms. 2 https://youtu.be/ANynzVfY32k Build a literature review workflow. Based on your request, I suggest a team of 3 agents: Retriever Reader Synthesizer Keep them, but add a 'Critic' agent. Got it. The team now consists of 4 agents: Retriever Reader Synthesizer Critic Approved. User User User Role Assigner Role Assigner Topology Designer Topology looks good. Move to next step. User Semantics Expert I have completed their profiles: Based on the previous discussion, the graph structure should be: How to effectively evaluate the performance of multi-agent orchestration? User We retrieved 20 academic papers on multi-agent systems. After reading, synthesizing, and critiquing them, the final report is as follows: ... Compiling Stage 1 Role Assignment Stage 2 Topology Design Stage 3 Semantic Completion Runtime Workflow Execution Sounds good, let's proceed. User Figure 1: Vibe Graphing in MASFactory. MASFac- tory turns a userâs natural-language intent into an exe- cutable multi-agent workflow via a three-stage, human- in-the-loop process, then compiles and executes the resulting workflow at runtime. achieve end-to-end coverage, robust error recovery, and multi-step coordination. Consequently, LLM- based multi-agent systems (MAS) have become a widely adopted approach to extend agentic problem solving through role specialization, cross-checking, and iterative collaboration (Li et al., 2023; Wu et al., 2023; Hong et al., 2024; Qian et al., 2024; Chen et al., 2024). For MAS modeling, an increasingly common orchestration abstraction is directed computation graphs. A graph consists of nodes that host com- 1 arXiv:2603.06007v1 [cs.CL] 6 Mar 2026 putation units (agents, tools, or sub-workflows) and edges that encode execution dependencies and message-passing directions. Pure directed acyclic graph (DAG) workflows are well-suited for pipeline-style collaboration, while cyclic structures are crucial for iterative processes such as reflection, revision, and retry. Recent frameworks have be- gun to explicitly represent multi-agent workflows as graphs. For instance, LangGraph models work- flow as a stateful graph with explicit execution semantics (LangChain, 2024), and Dify provides a workflow canvas where DAG dependencies de- fine both execution order and data flow (LangGe- nius, 2024). However, implementing complex MAS remains engineering-intensive. For exam- ple, developers have to manually craft role prompts for agent nodes, wire the routing logic between nodes, and establish inter-agent communication protocols. Also, real-world applications rely on heterogeneous context sources, including memory layers (Chhikara et al., 2025; Kang et al., 2025; Packer et al., 2024), retrieval-augmented genera- tion (RAG) (Lewis et al., 2020; Edge et al., 2024), and standardized tool/context integration protocols such as model context protocol (MCP) (Anthropic, 2025). Current frameworks often integrate them via workflow-specific glue code, making imple- mentation difficult to port and reuse across environ- ments. Finally, MAS development frequently in- volves repeated subgraphs that are globally similar but differ slightly in local configurations. Existing frameworks provide limited support for version- controlled, templated reuse of such subgraphs. To address these challenges, we present MAS- Factory, a composable orchestration framework for multi-agent systems with Vibe Graphing (illus- trated in Figure 1). Firstly, MASFactory introduces Vibe Graphing: users describe design intent in natu- ral language, and the system compiles it into a read- able, editable, and version-controlled structured intermediate representation, which is further com- piled into an executable workflow. This process incorporates human-in-the-loop interaction, allow- ing users to review, modify, and provide feedback through a visual interface. Secondly, MASFac- tory improves interoperability via Context Adapter that hides heterogeneity across different context sources. Thirdly, MASFactory improves reusability by providing configurable, reusable graph modules for common multi-agent collaboration patterns, en- abling developers to quickly assemble workflows without repeatedly implementing structurally sim- ilar subgraphs. Beyond these, MASFactory pro- vides a visualizer that supports visual inspection of workflow topology, runtime trace visualization, and human-in-the-loop interaction. Contributions.(1) We propose MASFactory, a graph-centric MAS orchestration framework with reusable components, pluggable context manage- ment, delivering both natural-language workflow generation and consistent reproducible results. (2) We introduce Vibe Graphing, a human-in-the-loop approach that compiles natural-language intent into executable graphs, reducing implementation ef- fort while achieving competitive performance with manually implemented workflows. (3) We repro- duce five representative MASs with MASFactory, and demonstrate competitive performance on seven public benchmarks. 2 Related Work LLM-based multi-agent systems.Recent work has demonstrated that coordinating multiple LLM agents can improve robustness and coverage via role specialization, cross-checking, and iterative collaboration (Li et al., 2023; Chen et al., 2024; Shen et al., 2023). For example, AutoGen pop- ularizes programmable multi-agent conversation patterns and group coordination (Wu et al., 2023). MetaGPT structures collaboration with role defini- tions and SOP-like procedures for complex tasks (Hong et al., 2024). ChatDev organizes software- development collaboration into staged role inter- actions (Qian et al., 2024). However, the imple- mentations of these works vary significantly, and their codebases often span from thousands to tens of thousands of lines, making it difficult for devel- opers to build upon them. Frameworks for MAS development. Beyond research prototypes, a growing ecosystem tar- gets practical MAS implementation. Googleâs Agent Development Kit (ADK) (Google, 2024) and CrewAI (CrewAI Inc., 2024) emphasize a code- first, process-driven methodology: the former pro- vides a toolkit towards deploying agentic applica- tions, whereas the latter focuses on the program- matic orchestration of collaborative agent crews. Alternatively, graph-centric frameworks such as LangGraph (LangChain, 2024) and Dify (LangGe- nius, 2024) represent agentic workflows as explicit node/edge structures to provide fine-grained con- trol over the execution flow. However, building 2 complex MAS remains engineering-intensive, re- quiring heavy manual configuration and tightly cou- pled context integrations. To simplify orchestration, we design MASFactory, which can translate user intent into executable graphs via Vibe Graphing. 3 System Design In this section, we present the architecture of MAS- Factory. As shown in Figure 2, at the bottom layer the system adopts a backbone composed of NodeandEdgefor modeling collaboration graphs. Built on top of this backbone, MASFactory pro- vides composable components and modules for flexible collaboration process implementation. Be- sides, MASFactory unifies MAS-critical mecha- nisms (communication protocols and context man- agement), and build them as pluggable modules. As a result, the system can conveniently integrate external frameworks such as Mem0 (Chhikara et al., 2025) and LlamaIndex (LlamaIndex, 2024) for bet- ter user experience. MASFactory also provides three orchestration interfaces: automated orches- tration via Vibe Graphing, and manual workflow implementation via declarative or imperative pro- gramming. To facilitate development and debug- ging, MASFactory also provides a a visualizer for topology preview, runtime tracing, and human-in- the-loop interactions throughout the workflow. 3.1 Basic Components Graph-based Organization. MASFactory models collaboration as a directed graph composed ofNode andEdge(Zhuge et al., 2024). ANodeis the basic computation unit and can be extended into freely composable components, includingGraph,Loop, Agent,CustomNode,Interaction, andSwitch. These components expose a consistent interface, but differ in their execution logic. AnEdgeex- presses inter-node dependencies and serves as the carrier of message passing. Collaboration Flow. MASFactory makes col- laboration signals explicit by separating them into three flows. Control flow propagates along edges to advance scheduling and dependencies, ensur- ing causal constraints of execution. Message flow propagates horizontally along edges to carry node outputs to downstream nodes. State flow propa- gates along the hierarchy between graphs and sub- graphs to synchronize graph-level context and run- time state. Node Lifecycle. At runtime, each node follows a unified lifecycle. A node first aggregates incoming messages along itsin edgesinto its input, then reads states from its parentGraph. It subsequently runs node-specific execution logic, e.g., invoking the LLM forAgent, scheduling internal nodes in topological order forGraphandLoop. After ex- ecution, the node dispatches produced messages via itsou edgesto downstream nodes, and finally writes updated states back to the parentGraphto synchronize shared states and support downstream execution. Runtime Scheduling. MASFactory adopts a readiness-based scheduling strategy that allows multiple ready nodes to execute concurrently. This unified mechanism supports sequential, parallel, branching, and cyclic control structures. 3.2 Key Components Graph and Loop.GraphandLoopare responsible for topology representation and scheduling of inter- nal nodes.Graphexpresses and schedules directed acyclic graph (DAG) workflows.Loopexpresses and schedules cyclic structures, and is commonly used for iterative collaboration patterns such as reflection, revision, and retry. Switch. ASwitchimplements control-flow rout- ing inside the graph. Unlike ordinary nodes that broadcast messages and trigger signals to all down- stream nodes by default,Switchdynamically se- lects and activates one or multiple downstream paths based on runtime state. Interaction. AnInteractionnode serves as the entry point of the human-in-the-loop mecha- nism. It can actively query users during execution, collect feedback, and inject user inputs back into the workflow. 3.3 Agent Component PerceptionâReasoningâAction.Agentadopts the classic PerceptionâReasoningâAction paradigm and modularizes key steps such as communication and context through pluggable designs. As indi- cated in Figure 2,Agentrelies on a pluggable Mes- sage Adapter for message processing and a plug- gable Context Adapter for context management. Message Adapter. For communication, the Message Adapterformats agent inputs and out- puts according to a given communication protocol. MASFactory provides a set of commonly used adapters, including protocols based on JSON schema, structured Markdown segments, and plain- text paragraph formats. It also exposes interfaces 3 Orchestration Interfaces Reusability Components Key Components Vibe Graphing Imperative Declarative NodeTemplate Basic Components LoopSwitch Agent Interaction Structure Collaboration Flows Graph Node Edge State Flow Message Flow Control Flow trigger Visualizer ComposedGraph Template A Template B Template C clone â Structure enable enable graph.create_node( ) graph.create_edge( ) graph.create_edge( ) nodes=( ) edges=( , ) g=Graph(nodes,edges) Editor & PreviewMonitor & TraceHuman-In-the-Loop Perception ReasoningAction Communication Protocol Message Adapter Context Management MCP Tools RAG Memory Context Adapter clone â Figure 2: Architecture overview of MASFactory framework. for user-defined protocols. By introducing Mes- sage Adapters, MASFactory decouples collabora- tion graph from protocol definitions, enabling pro- tocol extension or replacement without modifying the collaboration topology. Context Adapter. For context management, to shield heterogeneity across information sources such as Memory, MCP, and RAG (Packer et al., 2024; Kang et al., 2025; Anthropic, 2025; Lewis et al., 2020; Edge et al., 2024), MASFactory uti- lizes a Context Adapter to provide a standardized interface. This adapter segments diverse external contexts into standardized units, thereby enabling unified seamless integration with different context frameworks such as Mem0 and LlamaIndex. 3.4 Reusability and Templated Prototyping NodeTemplate. NodeTemplate allows users to de- clare a structural template first and instantiate it into a concrete graph later. This decoupling be- tween declaration and instantiation enables users to clone templates to build multiple graphs that share a similar global structure but differ in local configurations, supporting branch-style reuse and versioned management. Moreover, developers can reuse a graph-level template while adjusting node- level settings when instantiating the graph. ComposedGraph. ComposedGraph is a spe- cialized form ofGraphthat represents a class of predefined structures. It can instantiate a concrete graph by filling node configurations or activating specific branches according to user parameters, hid- ing low-level construction details. With Composed- Graph, users can package their designs as reusable composite components. Meanwhile, MASFactory uses ComposedGraph to encapsulate structures that are difficult to express with static graphs, such as DyLan-style dynamic scheduling patterns (Liu et al., 2024), as well as commonly used collabora- tion subgraphs. This supports broader application scenarios while reducing development cost. 3.5 Orchestration Interfaces Vibe Graphing. Under Vibe Graphing, MASFac- tory compiles natural-language intent into an exe- cutable multi-agent workflow through staged com- pilation, while providing human-in-the-loop review and revision at each stage. During this process, the system produces a readable, editable and struc- tured intermediate representation, which is then compiled into an executable workflow. As illus- trated in Figure 1, the pipeline completes three core tasks. Role Assignment maps task intent into a set of candidate agents with clear responsibility bound- aries. Structure Design generates a directed-graph topology skeleton based on inter-role information dependencies and control constraints, determining connectivity as well as the directions of message and control propagation. Semantic Completion per- forms parameterized instantiation over the skeleton 4 by configuring prompts and tools for each node, producing a workflow that can be compiled and ex- ecuted directly. This intentâstructureâinstantiation compilation chain elevates MAS construction from manual workflow configuration to an iterative de- sign process, reducing implementation cost while retaining control over topology and semantics. Imperative Interface. The imperative interface is code-centric: developers construct graphs by pro- grammatically instantiating nodes and edges and wiring them with explicit control logic. This style offers high flexibility and precise control over topol- ogy, parameters, and runtime behaviors, making it suitable for carefully engineered workflows and scenarios that require tight coupling with applica- tion logic. Declarative Interface. The declarative inter- face specifies a workflow as a structured configu- ration: developers declare the graph topology and node properties, and MASFactory constructs the executable graph accordingly. This style keeps programming concise and easy to review, and is recommended for fixed workflows and lightly dy- namic structures. 3.6 Visualizer The Visualizer is a visual integrated environment implemented as a VS Code extension. It aligns static workflow topology with runtime traces in a single view, and supports the following features: Editor & Preview. Editor & Preview supports real-time topology preview and structural inspec- tion during development. Monitor & Trace. The visualizer tracks node state evolution and message propagation during execution to support debugging and diagnosis. Human-in-the-Loop.Human-in-the-Loop works withInteractionnodes to visualize run- time user interactions and to incorporate external feedback or inputs into the Vibe Graphing work- flow, enabling interactive intervention and iteration. 4 Evaluation and Analysis We conduct extensive experiments to answer the following questions: (1) whether MASFactory can reproduce representative MAS methods with con- sistent effectiveness; (2) whether Vibe Graphing can produce competitive workflows compared with manually designed ones; and (3) whether MAS- Factory can reduce implementation cost through component reuse and intent-driven orchestration. 4.1 Experimental Setup Benchmarks. We evaluate on coding-oriented benchmarks (HumanEval, MBPP, BigCodeBench, SRDD) (Chen et al., 2021; Austin et al., 2021; Zhuo et al., 2025; Qian et al., 2024), and gen- eral reasoning/tool-use benchmarks (MMLU-Pro, GAIA, GPQA) (Wang et al., 2024; Mialon et al., 2024; Rein et al., 2024).All scores are re- ported in percentage scale (0â100). Coding bench- marks except SRDD report pass@1; SRDD re- ports an aggregate quality score (SRDD); MMLU- Pro/GAIA/GPQA report accuracy. LLM Backbones. For Vibe Graphing, the work- flow construction stage usesgpt-5.2to compile natural-language intent into an executable work- flow. For workflow execution of all methods, we use gpt-4o-mini. 4.2 Performance of Reproduced Workflows Table 1 compares five representative MAS methods implemented in MASFactory against their original implementations, including ChatDev (Qian et al., 2024), MetaGPT (Hong et al., 2024), AgentVerse (Chen et al., 2024), CAMEL (Li et al., 2023), and HuggingGPT (Shen et al., 2023). Overall, MAS- Factory reproductions achieve results broadly con- sistent or even better with the originals across differ- ent benchmarks. This indicates that MASFactory can cover diverse multi-agent architectures and col- laboration designs without systematic regressions. 4.3 Performance of Vibe Graphing We report two Vibe Graphing settings in Table 1. In Vibe Graphing-ChatDev, we replace each key phase of ChatDev with an individualVibeGraph component, and connect these phases into a work- flow using lightweight glue code. In contrast, Vibe Graphing-Task Specific is a task-driven variant: for each benchmark dataset, a developer writes a natu- ral language description of a workflow, and passes the instruction to a singleVibeGraphcomponent to compile it into an executable workflow. The last two rows of Table 1 reports the results for work- flows produced with Vibe Graphing. Despite using a different model only at the workflow construction stage (gpt-5.2), the resulting workflows execute withgpt-4o-miniand achieve competitive perfor- mance on coding benchmarks, as well as on general reasoning/tool-use tasks where applicable. These results suggest that staged intent-to-graph compi- lation can generate viable multi-agent workflows 5 Table 1: Main results are reported on a percentage scale (0-100). The symbol âââ indicates not applicable due to the incompatibility between programming-focused MASs and general-purpose reasoning benchmarks. MethodHumanEval MBPP BigCodeBench SRDD MMLU-Pro GAIA GPQA ChatDev (original)82.5071.4050.7082.91â ChatDev (MASFactory)81.3074.2053.3084.23â MetaGPT (original)67.0736.0350.1078.19â MetaGPT (MASFactory)89.0259.1451.7072.77â AgentVerse (original)85.0074.5465.9287.5564.6412.1238.39 AgentVerse (MASFactory)85.0075.1564.1291.0664.1612.7337.50 CAMEL (original)62.2060.6063.5189.4250.089.7032.59 CAMEL (MASFactory)71.8557.8078.1689.6963.0412.7324.78 HuggingGPT (original)82.3268.6028.4287.9665.599.0956.67 HuggingGPT (MASFactory)80.4964.4029.9183.2663.6610.9147.32 Vibe Graphing-ChatDev83.5074.2045.3088.13â Vibe Graphing-Task Specific84.7672.3751.6790.7151.7312.1239.51 that approach manually designed baselines, while substantially reducing low-level graph wiring and framework-specific engineering effort. 4.4 Case Study of Implementation Cost The original implementation of ChatDev contains 1,511 lines of Python code for workflow definition. With ComposedGraph-based reuse, our MASFac- tory reproduction reduces the total implementation to 1,114 lines while maintaining comparable per- formance as shown in Table 1. If we further use Vibe Graphing to make each ChatDev stage interac- tively generated (i.e., Vibe Graphing-ChatDev), the implementation only requires 203 lines to connect these stages. When we fully rely on Vibe Graph- ing to generate the workflow end-to-end (i.e., Vibe Graphing-Task Specific), the workflow specifica- tion shrinks to only 45 lines of code. Furthermore, under the samegpt-5.2backend, Vibe Graphing reduces API costs by roughly an order of magnitude compared to Vibe Coding, as shown in Table 2. Workflows generated via Vibe Coding frequently exhibit logical flaws in the con- structed graphs, failing to return correct execution results. Consequently, we restrict our comparison with Vibe Coding to cost analysis and exclude it from the performance evaluation. To summarize, composed components enhance reusability, while Vibe Graphing significantly low- ers development barriers by minimizing boilerplate and manual configuration. We provide a Vibe Graphing case study that walks through the work- flow construction pipeline from intent to an exe- cutable workflow in Appendix A. Table 2: Comparison of monetary cost between Vibe Graphing (VG) and Vibe Coding (VC). VC-L and VC- M denote the low and medium reasoning lengths of VC. Metric ChatDevAgentVerse VGVC-LVC-MVGVC-LVC-M Cost ($)0.263.493.020.594.436.08 5 Conclusion We present MASFactory, a graph-centric frame- work for orchestrating LLM-based multi-agent sys- tems. MASFactory models multi-agent workflows as executable directed graphs and integrates Vibe Graphing to compile natural-language intent into MAS workflows with human-in-the-loop refine- ment. It also provides reusable components, plug- gable context and a visualizer for topology preview, runtime tracing, and visual human-in-the-loop in- teraction. Experiments on seven public bench- marks show that MASFactory consistently repro- duces representative MASs and that Vibe Graph- ing produces competitive workflows while substan- tially reducing implementation overhead. Limitations MASFactory currently does not provide built-in checkpointing for resuming execution from in- termediate states after interruptions. In addition, we will continue to enrich and refine the built-in composed-component library in future updates. 6 References Anthropic. 2025. Model context protocol (MCP) speci- fication. Accessed: 2026-02-23. Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, and Charles Sutton. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732. Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, and 39 others. 2021. Evaluating large language models trained on code. Preprint, arXiv:2107.03374. Weize Chen, Yusheng Su, Jingwei Zuo, Cheng Yang, Chenfei Yuan, Chi-Min Chan, Heyang Yu, Yaxi Lu, Yi-Hsin Hung, Chen Qian, Yujia Qin, Xin Cong, Ruobing Xie, Zhiyuan Liu, Maosong Sun, and Jie Zhou. 2024. AgentVerse: Facilitating multi-agent collaboration and exploring emergent behaviors. In The Twelfth International Conference on Learning Representations (ICLR). OpenReview.net. Prateek Chhikara, Dev Khant, Shreyas Aryan, Tushar Singh, and Deshraj Yadav. 2025. Mem0: Building production-ready AI agents with scalable long-term memory. Preprint, arXiv:2504.19413. CrewAI Inc. 2024. CrewAI. Accessed: 2026-02-23. Darren Edge, Ha Trinh, Newman Cheng, Joshua Bradley, Alex Chao, Apurva Mody, Steven Truitt, and Jonathan Larson. 2024. From local to global: A graph RAG approach to query-focused summariza- tion. Preprint, arXiv:2404.16130. Google. 2024. Agent development kit (ADK). Ac- cessed: 2026-02-23. Sirui Hong, Mingchen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and JĂŒrgen Schmidhuber. 2024. MetaGPT: Meta pro- gramming for a multi-agent collaborative framework. In The Twelfth International Conference on Learning Representations (ICLR). OpenReview.net. Jiazheng Kang, Mingming Ji, Zhe Zhao, and Ting Bai. 2025. Memory OS of AI agent. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing (EMNLP). LangChain. 2024. LangGraph. Accessed: 2026-02-23. LangGenius. 2024. Dify: An LLM app development platform. Accessed: 2026-02-23. Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Hein- rich KĂŒttler, Mike Lewis, Wen-tau Yih, Tim Rock- tĂ€schel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-augmented generation for knowledge- intensive NLP tasks. In Advances in Neural Informa- tion Processing Systems (NeurIPS). Guohao Li, Hasan Hammoud, Hani Itani, Dmitrii Khizbullin, and Bernard Ghanem. 2023. CAMEL: Communicative agents for "mind" exploration of large language model society. In Advances in Neural Information Processing Systems (NeurIPS). Zijun Liu, Yanzhe Zhang, Peng Li, Yang Liu, and Diyi Yang. 2024. A dynamic LLM-powered agent net- work for task-oriented agent collaboration. In First Conference on Language Modeling (COLM). LlamaIndex. 2024. LlamaIndex. Accessed: 2026-02- 23. GrĂ©goire Mialon, ClĂ©mentine Fourrier, Thomas Wolf, Yann LeCun, and Thomas Scialom. 2024. GAIA: a benchmark for general AI assistants. In The Twelfth International Conference on Learning Representa- tions (ICLR). Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2024. MemGPT: Towards LLMs as operating sys- tems. In The Twelfth International Conference on Learning Representations (ICLR). Chen Qian, Xin Cong, Cheng Yang, Weize Chen, Yusheng Su, Juyuan Xu, Zhiyuan Liu, and Maosong Sun. 2024. ChatDev: Communicative agents for software development. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (ACL). David Rein, Betty Li Hou, Asa Cooper Stickland, Jack- son Petty, Richard Yuanzhe Pang, Julien Dirani, Ju- lian Michael, and Samuel R. Bowman. 2024. GPQA: A graduate-level google-proof q&a benchmark. In First Conference on Language Modeling (COLM). Timo Schick, Jane Dwivedi-Yu, Roberto DessĂŹ, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettle- moyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. In Advances in Neural Information Pro- cessing Systems (NeurIPS). Yongliang Shen, Kaitao Song, Xu Tan, Dongsheng Li, Weiming Lu, and Yueting Zhuang. 2023. Hugging- gpt: Solving ai tasks with chatgpt and its friends in hugging face. In Advances in Neural Information Processing Systems, pages 38154â38180. Curran As- sociates, Inc. Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Re- flexion: Language agents with verbal reinforcement learning. In Advances in Neural Information Pro- cessing Systems (NeurIPS). 7 Yubo Wang, Xueguang Ma, Ge Zhang, Yuanssheng Ni, Abhranil Chandra, Shiguang Guo, Weiming Ren, Aaran Arulraj, Xuan He, Ziyan Jiang, Tianle Li, Max Ku, Kai Wang, Alex Zhuang, Rongqi Fan, Xiang Yue, and Wenhu Chen. 2024. MMLU-Pro: A more robust and challenging multi-task language understanding benchmark. Preprint, arXiv:2406.01574. Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadal- lah, Ryen W White, Doug Burger, and Chi Wang. 2023. AutoGen: Enabling next-gen LLM appli- cations via multi-agent conversation.Preprint, arXiv:2308.08155. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R. Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations (ICLR). OpenReview.net. Mingchen Zhuge, Wenyi Wang, Louis Kirsch, Francesco Faccio, Dmitrii Khizbullin, and JĂŒrgen Schmidhuber. 2024. GPTSwarm: Language agents as optimizable graphs.In Proceedings of the 41st International Conference on Machine Learning (ICML), pages 62743â62767. Terry Yue Zhuo, Minh Chien Vu, Jenny Chim, Han Hu, Wenhao Yu, Ratnadira Widyasari, Imam Nur Bani Yusuf, Haolan Zhan, Junda He, Indraneil Paul, Simon Brunner, Chen Gong, Thong Hoang, Armel Randy Zebaze, Xiaoheng Hong, Wen-Ding Li, Jean Kad- dour, Ming Xu, Zhihan Zhang, and 14 others. 2025. BigCodeBench: Benchmarking code generation with diverse function calls and complex instructions. In The Thirteenth International Conference on Learning Representations (ICLR). 8 A Vibe Graphing Case Study Here we present a concrete Vibe Graphing exam- ple that illustrates the end-to-end pipeline from natural-language intent to a structured workflow specification and executable workflow definitions. A.1 Intent and Structural Constraint We start from a natural-language build instruc- tion that specifies both the task intent (weekly re- port writing) and an explicit structural constraint: STARTâA,B,CâDâEND, whereA,B, and Care parallel drafting agents andDis an evalua- tor/selector agent that produces the final output. The build instruction used in this case study is Design a workflow for writing my weekly report. I will provide what I worked on this week at the be- ginning. Then run three agents in parallel to draft separate reports, and pass all drafts to a fourth agent to evaluate and select the best one as the final output. The expected workflow structure is: STARTâA,B,CâDâEND. A.2 Interactive Workflow Construction As shown in Figure 5, we write a short program that constructs a minimal wrapper graph with the topologyENTRYâ VibeGraphâ EXIT. Here, VibeGraphis a built-in composed graph in MAS- Factory that activates the Vibe Graphing pipeline upon graph construction. As illustrated in Figure 1, the pipeline comprises three stages. Each stage is encapsulated by aLoopcomponent and centers around anAgentnode augmented with auxiliary mechanisms for correction, review, and human in- teraction throughInteraction. After each stage produces an intermediate design, the system solic- its user feedback and iteratively refines the result until the user accepts it, at which point the pipeline proceeds to the next stage. During the human-in- the-loop interactions in Stage 2 and Stage 3, users may either (i) edit the structured intermediate repre- sentation directly via the visualizer, or (i) provide feedback in the interaction panel. Both manual ed- its and textual feedback are recorded and fed back to theAgentas references for subsequent revisions. Figure 3 shows an example interaction trace in the visualizer, and Figure 4(a) shows the workflow pre- view and editing interface. A.3 Workflow Specification Snapshot As shown in Figure 6, we provide a snapshot of the structured intermediate representation gener- Figure 3: Human-in-the-loop interaction during Vibe Graphing in the visualizer. The user provides feedback to refine the role assignment and structure across stages. ated by Vibe Graphing. The representation explic- itly encodes: (i) node semantics (e.g.,labeland instructions), (i) input/output contracts (e.g., input_fieldsandoutput_fields), and (i) di- rected dependencies among nodes (i.e., edges). A.4 Workflow Execution At runtime, the visualizer provides a synchro- nized view of execution states and message traces, as shown in Figure 4(b). The workflow first collects user input and normalizes it into weekly_work_summary, then executes three draft- ing branches in parallel, and finally aggregates drafts for selection and light editing. 9 (a) IR preview and editing in the MASFactory Visualizer.(b) Runtime preview and trace alignment in the MASFactory Visualizer. Figure 4: Visualizer views used in the Vibe Graphing. from masfactory import VibeGraph, NodeTemplate, OpenAIModel, RootGraph invoke_model = OpenAIModel(api_key=os.environ.get("OPENAI_API_KEY",""), base_url=os.environ.get("OPENAI_BASE_URL",""), model_name="gpt-4o-mini") build_model = OpenAIModel(api_key=os.environ.get("OPENAI_API_KEY",""), base_url=os.environ.get("OPENAI_BASE_URL",""), model_name="gpt-5.2") weekly_report = NodeTemplate( VibeGraph, invoke_model=invoke_model, build_model=build_model, build_instructions="... START->A,B,C->D->END.", build_cache_path=GRAPH_DESIGN_CACHE_PATH, pull_keys="my_works":"what I worked on this week", push_keys="final_weekly_report":"final weekly report", ) root = RootGraph(name="demo2", nodes=[("weekly_report", weekly_report)], edges=[("ENTRY","weekly_report",), ("weekly_report","EXIT",)]) root.build() msg, attr = root.invoke(, "my_works": my_works) print(attr["final_weekly_report"]) Figure 5: MASFactory programming code for the Vibe Graphing. "edges": [ "source":"ENTRY","target":"DrafterA","source":"ENTRY","target":"DrafterB", "source":"ENTRY","target":"DrafterC","source":"DrafterA","target":"Finalizer", "source":"DrafterB","target":"Finalizer","source":"DrafterC","target":"Finalizer", "source":"Finalizer","target":"EXIT" ], "nodes": [ "id":"DrafterA","type":"Action","input_fields":["my_work"], "output_fields":["draft_report_a"],"instructions":"You are Weekly Report Drafting Agent A ...", "id":"DrafterB","type":"Action","input_fields":["my_work"], "output_fields":["draft_report_b"],"instructions":"You are Weekly Report Drafting Agent B ...", "id":"DrafterC","type":"Action","input_fields":["my_work"], "output_fields":["draft_report_c"],"instructions":"You are Weekly Report Drafting Agent C ...", "id":"Finalizer","type":"Action", "input_fields":["my_work","draft_report_a","draft_report_b","draft_report_c"], "output_fields":["final_weekly_report","selection_rationale"], "instructions":"You are the Weekly Report Evaluator ..." ] Figure 6: Workflow specification produced by Vibe Graphing. 10