DMAS-Forge: A Framework for Transparent Deployment of AI Applications as Distributed Systems

Alessandro Cornacchia, Vaastav Anand, Muhammad Bilal, Zafar Qazi, Marco CaniniarXiv 2025 · DOI · OpenReview

TL;DR

Deploying complex AI agent systems as distributed applications is a major hurdle. DMAS-Forge tackles this by decoupling agent logic from deployment specifics, allowing developers to write their agent systems once and then transparently deploy them across various environments with minimal manual effort. This framework aims to automate the generation of glue code and configurations, simplifying the transition from development to robust distributed systems.

What Problem Does This Paper Address?

The paper addresses the growing challenge of deploying sophisticated AI applications, particularly those built using multi-agent systems (MAS). As AI agents become more capable, they are increasingly designed to work together in distributed environments, mirroring service-oriented architectures. However, the rapid evolution of AI frameworks, communication protocols (like A2A and MCP), and deployment platforms (Kubernetes, serverless, etc.) makes it incredibly difficult and time-consuming for developers to package and deploy these MAS. Existing frameworks often hard-code deployment specifics, forcing developers to manually adapt their applications for each new environment or protocol, leading to significant engineering overhead and hindering optimization.

Methods

DMAS-Forge proposes a compiler-based approach to address this disconnect. The core idea is to separate the "what" (the agent's logic and workflow) from the "how" and "where" (the deployment environment and communication protocols).

  • Structural Agentic Workflow: Developers define their agent system as a computational graph, similar to existing frameworks like LangGraph. This graph specifies the agents, their tools, and how they communicate.
  • Deployment Specification: Developers provide a separate specification detailing how each agent and tool should be deployed (e.g., as a process, container, or serverless function), the choice of communication protocol, and any runtime constraints.
  • DMAS-Forge Compiler: This compiler takes both the workflow and deployment specifications as input. It automatically generates the necessary "glue code" and configuration files (like Dockerfiles and Kubernetes manifests) to deploy the agent system. The compiler ensures that agents comply with the specified communication protocols and can adapt to different deployment targets.

The framework is built upon the Blueprint microservices compiler, extending its capabilities to handle agentic AI applications.

Datasets

Not discussed in the paper.

Key Insights and Ideas

  • Decoupling is Key: The fundamental insight is that agent logic and deployment strategies are orthogonal concerns. By separating them, developers can focus on building intelligent systems without being bogged down by infrastructure complexities.
  • "Write Once, Deploy Everywhere": DMAS-Forge aims to enable a paradigm where agent applications are developed once and then flexibly ported to different execution environments and communication protocols.
  • Automation for Complexity: The rapid proliferation of agentic frameworks and deployment options necessitates automation. DMAS-Forge's compiler automates the tedious process of generating deployment configurations, saving significant manual effort.
  • Enabling Optimization: By abstracting away deployment details, DMAS-Forge opens the door for automated optimization pipelines. The framework can potentially analyze performance and resource usage to suggest or automatically implement better deployment strategies.

Key Results

The paper presents a prototype of DMAS-Forge implemented in Go. The prototype demonstrates the ability to:

  • Define agent applications using a structured workflow API.
  • Input deployment specifications through a wiring API.
  • Transparently deploy two agents (weather and news) as Linux containers, connecting them using RPC-over-HTTP.
  • Support for various plugins, including those for OpenAI-compatible models, vLLM for model deployment, and kagent for Kubernetes-native agent deployments.

While specific quantitative performance metrics are not detailed, the prototype showcases the feasibility of the proposed approach.

Limitations and Future Work

The authors acknowledge several limitations and outline promising future directions:

  • Runtime Environments: The current prototype supports Linux containers, but the vision is to extend support to a wider range of environments (e.g., serverless, Temporal).
  • Optimization Pipelines: A significant area for improvement is creating closed-loop optimization pipelines. This would involve automatically profiling applications, measuring communication patterns and resource usage, and restructuring the deployment for better performance without manual intervention.
  • Automatic Security Boundaries: Future work includes exploring how to automatically adjust security policies and determine minimal authorization for DMAS containers, especially when agents are dynamically co-located or disaggregated.
  • Agentic Framework Integration: A key open question is whether DMAS-Forge should build comprehensive agentic capabilities directly or act as an abstraction layer over existing frameworks. The latter would require techniques to redirect framework-specific communication primitives to distributed channels.

Summary updated

Abstract

Agentic AI applications increasingly rely on multiple agents with distinct roles, specialized tools, and access to memory layers to solve complex tasks -- closely resembling service-oriented architectures. Yet, in the rapid evolving landscape of programming frameworks and new protocols, deploying and testing AI agents as distributed systems remains a daunting and labor-intensive task. We present DMAS-Forge, a framework designed to close this gap. DMAS-Forge decouples application logic from specific deployment choices, and aims at transparently generating the necessary glue code and configurations to spawn distributed multi-agent applications across diverse deployment scenarios with minimal manual effort. We present our vision, design principles, and a prototype of DMAS-Forge. Finally, we discuss the opportunities and future work for our approach.
BibTeX
@misc{cornacchia2025dmas,
  author = {Alessandro Cornacchia and Vaastav Anand and Muhammad Bilal and Zafar Qazi and Marco Canini},
  title = {{DMAS-Forge: A Framework for Transparent Deployment of AI Applications as Distributed Systems}},
  year = {2025},
  eprint = {2510.11872},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2510.11872},
}
Figure