DynaMate2: Democratization of Agentic AI for Expert-Designed Custom Workflows

DynaMate2 is an open-source, hierarchical agentic framework that democratizes AI-driven scientific workflows by allowing researchers to easily convert their existing expert-defined Python tools into AI-callable components without requiring the LLM to generate scientific code, thereby lowering the barrier to automation in domains like computational chemistry.

The Gist

Imagine you have a massive, highly specialized library of tools that scientists have spent decades building. These aren't just hammers and screwdrivers; they are complex, custom-built machines that can simulate how atoms move, predict chemical reactions, or analyze massive amounts of data. The problem is, these machines only work if you know exactly how to pull the levers and push the buttons in the right order. If you want to use them, you usually need to be a master engineer yourself.

DynaMate2 is a new system designed to let anyone talk to these complex machines using plain English, without needing to know how to build or program them.

Here is how it works, using a simple analogy:

The "Smart Project Manager" and the "Specialized Workers"

Think of the scientific workflow as a construction project.

• The Old Way (DynaMate1): You had a single foreman who could only do one thing at a time. If you wanted to build a house, you had to tell the foreman to "lay the bricks," wait for him to finish, then tell him to "paint the walls," wait, then "install the roof." You had to micromanage every single step.
• The New Way (DynaMate2): You now have a Smart Project Manager (the Supervisor AI) and a team of Specialized Workers (the Agents).

When you walk up to the Smart Project Manager and say, "Build me a simulation of salt water," the Manager doesn't try to do the work itself. Instead, it breaks your big request down into small tasks:

1. "Go get the blueprint for the salt water model."
2. "Build the container."
3. "Run the simulation."
4. "Draw the results."

The Manager then hands each task to the specific Specialized Worker who is best at that job. One worker might only know how to download models, another only knows how to pack molecules into a box, and another only knows how to draw graphs.

The Golden Rule: The AI Never Builds the Machine

This is the most important part of the paper. In many new AI systems, the AI tries to write the code for the tools itself. The authors of this paper say, "No."

They believe that if an AI tries to write complex scientific code, it might make a mistake that ruins the experiment. So, in DynaMate2:

• The Scientists (the experts) write the code for the tools. These tools are already tested, proven, and safe.
• The AI (the Manager) never writes the code. It only decides which tool to use and passes the instructions to that tool.

It's like a restaurant. The AI is the waiter who takes your order and tells the chef what to cook. The waiter doesn't try to cook the food themselves; they just make sure the right chef (the expert tool) gets the right order.

How You Add Your Own Tools (The "Plug-and-Play" Feature)

One of the biggest hurdles in the past was that if a scientist wanted to add their own custom tool to the system, they had to be a computer programmer to edit the system's code.

DynaMate2 changes this with a Tool Registration Protocol. Imagine the system has a "Plug-and-Play" port.

• You have a script: You can paste your existing Python code directly into a chat box.
• You have a file: You can tell the system, "Here is my file, please add it."
• You have an idea: You can say, "I need a tool that does X, Y, and Z," and the system will actually write the code for you based on your description.

Once you "plug it in," the system remembers it forever. Next time you start the computer, your custom tool is still there, ready to be used by the Smart Project Manager.

A Real-World Example from the Paper

The authors tested this with a complex task called Molecular Dynamics (simulating how atoms move).

1. They registered four different tools: one to download a model, one to build a box of molecules, one to run the simulation, and one to analyze the results.
2. They gave the system one single sentence: "Download the MACE model, build a box with 262 water molecules and a salt ion, run a simulation at 300 Kelvin, and plot the energy."
3. The Smart Project Manager figured out the order, called the Specialized Workers one by one, passed the data from one step to the next, and produced the final graph.

The user didn't have to write a single line of code or click a button during the process. They just gave the order, and the system executed the entire workflow.

Why This Matters

The paper argues that scientists have spent years building amazing, validated tools, but they are stuck in isolation. DynaMate2 acts as a bridge. It allows these existing tools to talk to each other and be controlled by a simple conversation, making advanced scientific automation accessible to researchers who aren't AI experts.

In short: DynaMate2 is a system that lets you hire a team of specialized robot workers, managed by a smart AI boss, to do your complex scientific experiments just by talking to them—using tools you already trust and have built yourself.

Technical Summary

Technical Summary: DynaMate2

Problem Statement
While Large Language Model (LLM) agentic frameworks have demonstrated potential in automating scientific workflows, existing systems face a critical adoption barrier: they are typically built for specific, pre-defined task sequences. Adapting these frameworks to new domains or integrating custom, expert-developed tools requires substantial programming expertise. This limitation is particularly acute in fields like computational chemistry and materials science, where research groups have invested years building specialized, validated Python codebases. Current frameworks often force users to manually decompose workflows into multiple prompts or require deep machine learning knowledge to modify the system's source code. Furthermore, many existing approaches rely on LLMs to generate scientific code, introducing risks of errors in critical computations and compromising the integrity of domain-specific knowledge.

Methodology
The authors present DynaMate2, a hierarchical agentic framework and open-source template designed to lower the barrier for integrating expert-defined Python functions into AI-supervised multi-agent pipelines. The system is built on LangGraph, utilizing a dynamic state machine architecture rather than linear chains.

• Hierarchical Architecture: The framework employs a three-tier hierarchy:
  1. Supervisor Agent: A routing LLM that decomposes high-level user goals into structured sub-tasks and dispatches them to specialist agents.
  2. Specialist Agents: A pool of agents, each equipped with specific user-registered tools. These agents operate in independent ReAct loops, executing tools and reporting results.
  3. Tool Layer: Domain logic resides entirely in expert-defined, validated Python functions. The LLM is explicitly restricted from generating scientific code; its sole responsibility is routing, tool selection, and planning.
• Runtime Extensibility: A core innovation is the ability to register tools and agents at runtime without modifying the framework's source code. Tools can be added via inline code, existing source files, or plain-language descriptions.
• Persistence: The system uses a PoolStore component to serialize tool source code to .py files and agent metadata to JSON. A SQLite-backed checkpointer preserves conversation states and tool registries across sessions, allowing researchers to build custom workflows iteratively.
• PromptEnhancer: A preprocessing module that inspects incoming user messages, queries the current tool/agent registry, and rewrites prompts to include routing hints (target agent and specific tool), thereby reducing the supervisor's search space and improving routing reliability.

Key Contributions

1. Tool Registration Protocol: The paper introduces a step-by-step protocol for converting validated Python functions into LLM-callable tools. This includes structural requirements (e.g., moving imports inside function bodies to prevent registration-time errors) and three registration pathways: from inline code, from source files, and via natural-language descriptions (where the LLM generates the code).
2. Dynamic Agent Pool: Unlike previous iterations (e.g., DynaMate1) which functioned as single-agent systems, DynaMate2 supports a persistent pool of specialist agents that can be added, modified, or removed via natural language instructions during a session.
3. Safety-Centric Design: By strictly separating domain logic (expert code) from orchestration logic (LLM routing), the framework eliminates the risk of LLM-generated code errors in scientific calculations.
4. Open-Source Implementation: The authors release a reference implementation with a web-based Gradio interface, serving as a reusable template for the community.

Results
The framework was validated through an end-to-end molecular dynamics (MD) workflow executed from a single natural-language instruction. The workflow involved:

1. Model Retrieval: Downloading a MACE-MP-08 machine-learning interatomic potential (MLIP) foundation model.
2. System Construction: Converting SMILES strings to XYZ coordinates and using Packmol to build a periodic simulation box for a NaCl-water system.
3. Simulation Execution: Running a 100-step NVT molecular dynamics simulation at 300 K using the MLIP.
4. Trajectory Analysis: Automatically extracting energy and temperature data and generating a two-panel visualization.

This workflow was constructed by registering four distinct tools (download, system build, simulation, analysis) and assigning them to a specialist agent (mace_md_specialist). The supervisor successfully decomposed the high-level prompt, routed tasks to the specialist, and managed context (file paths, model IDs) across all sub-steps without user intervention. Compared to the previous DynaMate1 system, which required multiple manual prompts and interactions for the same complexity, DynaMate2 completed the entire pipeline in a single session thread.

Significance and Claims
The authors claim that DynaMate2 addresses a primary factor limiting the adoption of agentic AI in scientific research: the difficulty of integrating existing, validated code into automated pipelines. By treating the agent pool as a dynamic, user-managed resource, the framework enables researchers to leverage their years of domain expertise without needing to become AI engineers.

The paper emphasizes that the framework serves as a template rather than a finished product. Its value is designed to grow with the community; as more groups register their validated tools, the supervisor's ability to compose complex, novel workflows increases. The authors position DynaMate2 as a bridge between the "expert-developed tools" that already exist in scientific communities and the "AI-driven automation" needed for next-generation research, aiming to accelerate the rate at which scientific knowledge can be obtained.

Limitations and Future Directions
The authors acknowledge current limitations, including:

• Agent Reliability: Specialist agents may occasionally fail to execute tools before returning control to the supervisor, a fragility addressed by injected execution rules but requiring further principled solutions (e.g., constrained decoding).
• Tool Generation Quality: Code generated from natural-language descriptions may contain subtle errors not caught until runtime.
• Sequential Execution: The current implementation runs agents sequentially within a single process, limiting throughput for parallelizable tasks.

Future work aims to introduce parallel agent execution, integrate robotic laboratory platforms for closed-loop experimental workflows, and develop a community tool registry to facilitate sharing of validated tools across domains.