💻 computer science

From Intent to AI Pipelines: A Controlled Agentic Framework for Non-AI Expert Scientists

The paper introduces Domain-Driven Adaptable AI Pipelines (DDAP), a controlled, human-in-the-loop agentic framework that leverages large language models to guide non-expert scientists through a structured, four-stage process for generating competitive, domain-specific AI pipelines and implementation code.

Original authors: Hyacinth Ali, Jessie Galasso-Carbonnel, Houari Sahraoui

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hyacinth Ali, Jessie Galasso-Carbonnel, Houari Sahraoui

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a brilliant scientist in biology, agriculture, or social science. You have a great idea for a research project, but to make it happen, you need to build a complex "AI machine" (a pipeline) to analyze your data. The problem is, building this machine usually requires a degree in computer science and years of coding experience. Most scientists don't have that time or training, so they have to wait for a specialist to help them, which slows everything down.

This paper introduces DDAP (Domain-Driven Adaptable AI Pipelines), a new tool designed to act like a smart, step-by-step construction foreman for these scientists.

Here is how DDAP works, using simple analogies:

1. The Problem: The "Black Box" vs. The "Blueprint"

Usually, if you ask a computer (specifically a Large Language Model or LLM) to "build me an AI," it might just spit out a pile of code. Sometimes it works, but often it's broken, missing pieces, or doesn't fit your specific needs. It's like ordering a custom house from a robot that just throws bricks at you without a plan.

DDAP changes the game. Instead of asking for the whole house at once, DDAP breaks the construction down into four distinct stages, ensuring every step is checked and approved before moving to the next.

2. The Four Stages of Construction

Stage 1: The Architect's Meeting (Problem Definition)

What happens: You talk to the system in plain English. You say, "I have images of jute pests and I want to sort them into 17 types."
The Magic: The system doesn't just nod; it acts like a curious architect. It asks you clarifying questions based on your field (e.g., asking a medical researcher about patient privacy, or an agricultural researcher about crop types). It turns your vague idea into a clear, written blueprint (a "problem definition artifact").

Stage 2: The Site Survey (Compute Environment)

What happens: Before building, you need to know what tools and space you have. Do you have a super-fast computer (GPU) or just a regular laptop? Do you have a budget?
The Magic: The system helps you define these limits and writes them down as a spec sheet. This ensures the final AI isn't built on a foundation that is too heavy for your computer to hold.

Stage 3: The Design Phase (Pipeline Generation)

What happens: Now the system designs the actual "machine."
The Magic: Instead of guessing one way, the system acts like a team of five different engineers. It generates five different design options for your AI pipeline. It weighs the pros and cons of each (e.g., "Option A is faster, but Option B is more accurate"). It picks the best designs and saves them as design documents.

Stage 4: The Construction Crew (Code Generation)

What happens: Finally, the system writes the actual computer code (the bricks and mortar) based on the chosen design.
The Magic: If the code has a mistake (a typo or a missing tool), the system has a built-in "fix-it" mechanic. It sees the error, asks the computer to fix it, and tries again until the code runs smoothly.

3. The "Human-in-the-Loop" Safety Net

The most important part of DDAP is that it is controlled. It doesn't just run away and do everything on its own. It keeps the scientist in the driver's seat.

Think of it like a GPS with a co-pilot. The GPS (the AI) suggests the route, but you (the scientist) confirm the destination and the stops. If the GPS tries to take you down a road that doesn't exist, the system stops and asks for clarification. This prevents the AI from making wild, incorrect guesses.

4. Did It Work? (The Results)

The authors tested this "foreman" on real-world problems in six different areas:

Biology: Sorting images of pests.
Medicine: Predicting Parkinson's disease progression from voice recordings.
Business: Sorting product titles and grouping customers.
Environment: Identifying types of waste from photos.
Finance: Predicting stock market trends.

The Results:

Success: In most cases (like sorting pests, predicting Parkinson's, and sorting products), the AI pipelines built by DDAP performed just as well as, or even better than, models built by human experts who spent weeks tuning them.
The Struggle: The system struggled a bit with text clustering (grouping similar text documents together). It's like the foreman is great at building houses but still learning how to organize a library. The results here were much lower than expert models.

The Bottom Line

DDAP is a tool that lets non-expert scientists build powerful AI models by having a structured, guided conversation with a computer. It turns the scary, complex process of "coding an AI" into a manageable, four-step checklist.

It proves that you don't need to be a coding wizard to use AI; you just need a good guide that translates your scientific goals into a working machine, step-by-step, while keeping you in control the whole time.

Technical Summary: Domain-Driven Adaptable AI Pipelines (DDAP)

Problem Statement

Artificial Intelligence (AI) pipelines have become essential for modern research across diverse fields, including medical sciences, agriculture, and social sciences. However, the design and implementation of end-to-end AI systems remain a significant barrier for non-expert scientists. Developing effective AI solutions requires multi-level expertise: formulating research questions as AI tasks, data preparation, model selection and training, and deployment. Current solutions present specific limitations:

Low-code/No-code platforms: While they lower technical entry points, they often lack flexibility, adaptability to domain-specific constraints, and support for the full pipeline lifecycle.
Direct Large Language Model (LLM) usage: Using LLMs to generate code from natural language descriptions faces challenges regarding reliability (producing incomplete or non-reproducible pipelines), adherence to domain constraints (e.g., regulatory requirements), and the high cognitive load required for non-experts to validate and debug outputs.
Methodological Gap: Existing tools do not sufficiently operationalize the transition from problem descriptions to machine learning workflows in a way that is accessible to non-experts while maintaining reproducibility and transparency.

Methodology: The DDAP Framework

To address these challenges, the authors propose Domain-Driven Adaptable AI Pipelines (DDAP), a controlled, human-in-the-loop, agentic framework. DDAP treats AI pipeline construction as a software engineering problem, synthesizing executable workflows from high-level domain intent under uncertainty. Rather than relying on fully autonomous generation, DDAP orchestrates LLMs as specialized agents within a staged workflow.

The framework structures the development process into four distinct stages, producing a set of structured artifacts ( $A = \{A_1, A_2, A_3, A_4\}$ ) that are persisted and reused across stages:

Problem Definition ( $A_1$ ):
- Goal: Elicit and structure the AI task into a semi-formal representation.
- Mechanism: An open-ended dialogue where the system profiles the researcher's domain and expertise level. It uses role-based prompting, guardrails, and chain-of-thought (CoT) reasoning to guide the user in clarifying objectives, data characteristics, and constraints.
- Output: A structured problem definition artifact.
Compute Environment Specification ( $A_2$ ):
- Goal: Align problem requirements with feasible computational resources.
- Mechanism: The orchestrator reuses the problem definition to contextualize prompts, eliciting details on environment location (on-premises/cloud), accelerators (GPUs/TPUs), storage, and budget.
- Output: A compute environment specification artifact.
Pipeline Generation ( $A_3$ ):
- Goal: Generate structured AI pipeline specifications.
- Mechanism: This stage is decomposed into two steps: (1) generating candidate preprocessing strategies and (2) generating complete pipeline designs. The framework generates five alternative pipeline candidates per task to mitigate the probabilistic nature of LLMs. It employs Retrieval-Augmented Generation (RAG), CoT, and guardrails to ensure designs align with domain requirements and resource constraints.
- Output: Multiple alternative pipeline specification artifacts with pros and cons.
Code Generation ( $A_4$ ):
- Goal: Translate selected pipeline specifications into executable code (e.g., PyTorch, TensorFlow).
- Mechanism: Code-oriented LLMs (e.g., Code Llama) are used with prompts augmented by artifacts from previous stages. An optional code repair mechanism is included, where the orchestrator feeds error messages back to the LLM to identify and fix syntactic or runtime errors without manual debugging.
- Output: Executable implementation code.

The framework relies on a central Pipeline Orchestrator that manages the interaction loop, ensuring traceability and maintaining control logic throughout the process.

Key Contributions

The paper outlines four primary contributions:

Artifact-Driven Formulation: It models pipeline construction as a staged synthesis process transforming high-level intent into executable artifacts, moving beyond AutoML approaches that rely solely on searching predefined components.
Controlled Agentic Framework: Unlike static low-code templates, DDAP dynamically adapts to domain context, user expertise, and resource constraints through guided interaction and staged refinement.
Orchestrated Multi-Stage Workflow: It decomposes pipeline generation into coordinated stages with explicit artifact reuse and control logic, improving reproducibility and user control compared to single-step LLM prompting.
Empirical Evaluation: It demonstrates that DDAP can generate competitive AI pipelines in a single pass (without iterative optimization) across multiple domains, while explicitly identifying limitations in complex tasks like textual clustering.

Experimental Results

The authors evaluated DDAP across six experiments spanning biology, business, and health sciences, comparing DDAP-generated models against expert-developed baselines from existing literature.

Competitive Performance: In several tasks, DDAP achieved results comparable to or superior to expert models without iterative hyperparameter tuning.
- Parkinson's Telemonitoring (Regression): DDAP's ensemble model achieved a Mean Absolute Error (MAE) of 0.30 (Motor UPDRS) and 2.66 (Total UPDRS), outperforming the expert baseline (4.5 and 6.0, respectively).
- Stock Market Forecast (Regression/Classification): DDAP achieved 79.44% accuracy, surpassing the expert baseline of 68%.
- Product Classification (Text): DDAP achieved 96.83% validation accuracy, exceeding the expert baseline of 95%.
- Jute Pest Classification (Image): DDAP achieved an F1-score of 0.94, slightly below the expert baseline of 0.97 but demonstrating strong capability in a single pass.
- Waste Material Classification (Image): DDAP achieved 84% F1-score, competitive with the expert baseline of 90%.
- Customer Segmentation (Clustering): DDAP generated meaningful RFM-based segments with a Silhouette Score of 0.53, aligning with expert-driven behavioral distinctions.
Limitations: The framework showed significant performance gaps in text-based clustering tasks. For the product clustering task, DDAP's best F1-score was 0.001, drastically lower than the expert baseline of 0.59. The authors attribute this to the need for more advanced representation learning and iterative optimization strategies for complex textual data.

Significance and Claims

The paper claims that DDAP demonstrates the viability of a controlled agentic framework for democratizing AI development. By combining guided interaction, adaptability, and reproducibility, the framework allows non-expert users to generate competitive AI pipelines.

The significance of the work lies in its ability to bridge the gap between accessibility and technical rigor. It does not claim to replace expert intervention entirely but rather to provide a structured, artifact-driven pathway that lowers the barrier to entry while maintaining alignment with software engineering principles (modularity, separation of concerns). The authors position DDAP as a unification of Low-Code/No-Code accessibility, AutoML's structured generation, and LLMs' contextual adaptability, offering a reproducible alternative to ad-hoc, fragile LLM-generated code. The framework is presented as a step toward making AI development more accessible, adaptable, and reproducible across scientific disciplines.