MIT and Microsoft Introduce Murakkab to Optimize Resource-Heavy Agentic AI Workflows

Researchers from the Massachusetts Institute of Technology (MIT) and Microsoft have developed Murakkab, an intelligent system designed to automatically optimize and streamline multi-step agentic AI workflows. Scheduled for presentation at the 20th USENIX Symposium on Operating Systems Design and Implementation (OSDI 2026), the system introduces an orchestration layer that separates high-level workflow design from low-level execution and hardware configuration. In empirical evaluations, Murakkab reduced graphics processing unit (GPU) demands to 35% of the capacity required by conventional orchestrators, cut energy consumption to 27%, and lowered deployment costs to less than 25% while maintaining strict latency and quality constraints.

The Efficiency Bottlenecks of Imperative Agent Workflows

Agentic workflows chain multiple artificial intelligence models and external tools—such as databases, web browsers, and code interpreters—to automate complex, multi-turn reasoning tasks. Popular applications of this architecture include:

• Multimodal Generation: Analyzing long video files, extracting visual features, and synthesizing answers to user questions.
• Automated Software Engineering: Generating, testing, and iteratively debugged code in an active environment.
• Collaborative Reasoners: Coordinating multiple specialized models to tackle complex mathematical or logical problems.

In conventional development frameworks, programmers must manually write imperative scripts to define every execution step of these workflows. They must hard-code which specific models and tools run at each step, how data flows between them, and what physical hardware instances host them. This manual configuration is highly challenging because of the vast configuration space. Developers are forced to choose from hundreds of potential combinations of language models, local tools, cloud APIs, and GPU types.

Furthermore, cloud infrastructures are blind to the internal structures of these workflows. To the cloud platform, the workflow looks like an opaque sequence of black-box model and tool calls. Because the hosting platform cannot inspect the underlying execution logic, it cannot efficiently share hardware, co-locate tasks, or schedule computing power across concurrent workloads. This structural separation results in significant GPU idling, inflated cloud bills, and degraded Service-Level Objectives (SLOs).

Declarative Abstraction: Decoupling Intent from Implementation

To address these inefficiencies, the researchers designed Murakkab—named after the Urdu word meaning “a composition of things”. The system operates on a core principle: separating what a developer wants an application to do from how the cloud platform actually executes it.

Instead of hard-coding exact model and hardware specifications upfront, developers declare their workflow’s high-level intent and task dependencies using natural language. For example, a developer does not need to choose specific models or GPU clusters for a video-understanding pipeline. Instead, they write a declarative specification mapping the logical steps of the task:

# Declarative task specification in Murakkab
scene_detect = "Given a list of videos, identify scenes in each."
frame_extract = "Given a list of scenes, extract frames."
stt = "Given a list of scenes, convert audio to text."
q_a = "Answer the query given some context."

During deployment, Murakkab translates this high-level specification into an optimized execution graph through three primary lifecycle phases:

1. Task Decomposition: The compiler interprets the logical requirements and identifies potential models and tools suited for each task.
2. Dependency Modeling: The system analyzes the data dependencies to determine which steps must run sequentially and which can execute in parallel to maximize performance.
3. Hardware Mapping: The platform automatically maps individual components to the ideal hardware instances and allocates computational resources at runtime.

This decoupled architecture allows developers to focus purely on application logic. If a cloud provider introduces a more advanced model or a more efficient GPU accelerator, the underlying platform automatically adapts the execution plan without requiring the developer to rewrite or redeploy their code.

The Architecture: Profile-Guided Optimizer and Adaptive Runtime

The Murakkab framework relies on two primary components to manage the physical and software stack at deployment time: an offline profile-guided optimizer and an online adaptive runtime.

Profile-Guided Optimizer

The profile-guided optimizer evaluates various combinations of models, tools, and hardware configurations to find the most efficient execution path. Because agentic workflows are highly sensitive to model sizing and tool options, the optimizer profiles these components to map the performance trade-offs between:

• Accuracy: The quality of the generated outputs.
• Latency: The end-to-end processing time for a complete workflow execution.
• Energy: The power consumed by the underlying computing nodes.
• Infrastructure Cost: The financial expense of the utilized cloud resources.

Based on this profiling, the optimizer automatically generates a customized execution plan tailored to satisfy user-defined SLOs, such as prioritizing output quality while maintaining a strict latency budget.

Adaptive Runtime

During execution, the adaptive runtime continuously monitors performance and dynamically reconfigures the workflow in response to real-time fluctuations in load or user preferences. If a user prioritizes budget efficiency, the runtime can dynamically switch tasks to cheaper, smaller models or local hardware nodes. If speed is prioritized, the system can instantly scale out compute allocations to minimize latency.

Crucially, this design gives cloud providers end-to-end visibility across multiple concurrent workloads. Instead of managing applications as isolated black boxes, the cloud platform can co-locate tasks, share hardware devices, and multiplex resources across multiple tenants to prevent waste.

Empirical Evaluation: Slashing Compute, Energy, and Cloud Costs

The research team evaluated Murakkab on representative workloads—including video question-answering, code generation, and mathematical problem-solving—using production-scale traces. They benchmarked its performance against state-of-the-art agentic orchestration frameworks, including LangGraph.

The evaluations demonstrated that Murakkab met the required quality and latency SLOs while substantially reducing infrastructure requirements:

• Compute Reductions: Murakkab used only 35% of the computational resources demanded by conventional methods, which represents an approximate 2.8x reduction in GPU usage.
• Energy Savings: The system consumed only 27% of the energy of traditional deployments, delivering a 3.7x reduction in power draw.
• Cost Efficiency: Deployment costs dropped to less than 25% of baseline configurations, representing a 4.3x reduction in overall cloud expenses.

The system’s dynamic trade-off capabilities were highly pronounced in testing. In one tested scenario, Murakkab reduced a workflow’s energy consumption by more than an order of magnitude with only about a 2% drop in overall accuracy. Additionally, the optimizer successfully identified an unexpectedly optimal, non-obvious configuration for a frame-selection model in a video question-answering workflow. The researchers noted that this type of fine-grained configuration would be virtually impossible for a developer to identify manually.

Collaborative Research and Funding

The research behind Murakkab was a collaborative effort between the MIT Computer Science and Artificial Intelligence Laboratory (CSAIL) and Microsoft Azure. The paper’s authors include:

• Gohar Irfan Chaudhry, lead author and PhD student in EECS at MIT.
• Adam Belay, associate professor of EECS and member of the Parallel and Distributed Operating Systems group at MIT CSAIL.
• Esha Choukse, Haoran Qiu, Íñigo Goiri, and Rodrigo Fonseca, researchers at Microsoft Azure Research.
• Ricardo Bianchini, Technical Fellow and Corporate Vice President at Microsoft Azure.

“Agentic workflows are getting very complicated and quickly becoming the backbone of what cloud providers are doing,” Gohar Chaudhry said of the project. “Energy usage is a huge concern, so we need to be very careful about how efficient these workflows are.”

The work received funding support in part from the Semiconductor Research Corporation and the U.S. Defense Advanced Research Projects Agency (DARPA). The research findings will be presented at OSDI 2026, held in Seattle, Washington.