Agentic and Model-Driven Development

Last modified: October 19, 2026

Introduction

AI changes how teams build software. AI agents can now take a development goal, decide which steps are necessary, use tools, and change several parts of an application in one task. This way of working is called agentic development. It creates new questions for development teams, such as:

How do you direct an agent?
How do you keep the quality of its output high?
How do you review its work?
What is the role of the developer?

This document describes what agentic development is, why model-driven development and agentic development reinforce each other, and how Mendix AI Assistance (Maia) and other agents work with professional developers. For an overview of all Maia capabilities, see Maia Make Capabilities.

What Is Agentic Development

In agentic development, you give an AI agent a goal, and the agent carries out the development work to reach it. An agent has the following characteristics:

It works toward a goal. You describe the outcome, for example, a new feature or a change to existing logic. The agent uses this information to determine which documents to create or change.
The agent uses built-in capabilities and connected tools, such as MCP servers or web content, to get information and to make changes.
It works across documents. One request can result in changes to the domain model, pages, and microflows together.
The agent can ask clarifying questions before it continues.
It works with context that you provide. The agent follows your instructions, conventions, and domain knowledge.

The developer directs the agent, provides context, and reviews the results, while the agent handles the actual implementation work.

In Mendix, Maia is the agent built into the platform. In Studio Pro, Maia Make works as an agent: it uses your app model as context, considers its built-in capabilities and your enabled MCP tools, and creates and changes regular Mendix documents. You can also use your own agent with Studio Pro through the Studio Pro MCP Server.

How Agentic Development Changes Software Delivery

In traditional software delivery, a large part of the effort goes into producing the application, such as writing code and modeling each element by hand. Agentic development changes where the effort goes:

From producing to specifying – The quality of an agent's output depends on how clearly you describe the intended behavior. Provide clear requirements, user stories, and acceptance criteria to help the agent implement the feature as expected.
From producing to reviewing – Agent output can contain mistakes. Review every change to verify they meet the requirements and work correctly within the application.
From single steps to complete tasks – An agent can apply changes to several parts of an app in one task. Define the scope of the task clearly and provide sufficient context and constraints to guide the changes.
From individual knowledge to shared context – An agent rely on the context provided to it. Document team conventions, architecture decisions, and domain knowledge to get more consistent results.

These shifts apply to all forms of software development. The way a platform represents an application determines how well a team can work with agents within these shifts.

Why Model-Driven Development Matters for Agents

In Mendix, an app is a model. The model consists of documents with a defined structure, such as domain models, pages, microflows, and workflows. The Mendix Runtime runs this model. This approach has specific advantages when an agent builds or changes an app.

A Higher Level of Abstraction

Model elements describe an app at a higher level than code. For example, a Retrieve activity in a microflow describes a complete data retrieval, including its source and its constraints. When an agent generates a model, it works at this level.

Built-in Validation

Studio Pro continuously checks the model for consistency errors. This check applies to every document, whether you or an agent created it. For example, if a generated microflow refers to an attribute that does not exist, the Errors pane shows the error immediately. You do not have to run the app to find this type of mistake.

In Studio Pro 11.12.1 and above, you can ask Maia to explain or solve a consistency error from the Errors pane.

Visual Review

Agents create standard model documents that you can review in the same editors you use to create them. For example, review a generated microflow as a diagram, a generated page in the page editor, and a generated domain model in the domain model editor.

Platform-Provided Foundations

The Mendix Platform provides many foundations of an app, such as the runtime, data persistence, and the security model. An agent creates the parts that are specific to your app, such as entities, pages, and logic. These parts build on the same platform foundations as documents that you model yourself.

One Shared Language for People and Agents

Developers, business analysts, and agents all work with the same model documents. A user story in Mendix Portal can become a domain model and pages in Studio Pro. An explanation from Maia refers to the same microflows and entities that you see in the App Explorer. This shared language reduces the gap between what is asked, what is built, and what is reviewed.

How Agents Strengthen Model-Driven Development

Agents also make model-driven development stronger. Maia helps in the following areas:

Starting – Maia generates a first version of an app, a module, or a document. You do not start from an empty model.
Learning – New developers learn Mendix concepts with Maia Learn and ask questions in the Maia Make chat while they model.
Understanding – Maia Explain describes the purpose and details of existing logic and pages. This helps when you take over an app that someone else built.
Repetitive work – Maia creates overview pages, validation logic, translations, and similar repetitive parts. You can focus on the parts that need your expertise.
Consistency – Agent instructions and agent skills let Maia and other agents apply your team conventions, such as naming rules, every time they create a document.
Quality – Best Practice Recommender detects anti-patterns in the model and helps you fix them.

The Role of the Developer

Agents complement professional developers; they do not replace them. An agent can create documents and carry out tasks, but it relies on the context developers provide to understand business requirements, users, and quality standards. In agentic development, the developer directs the work, and the development team remains responsible for the application.

The table below shows how the work is divided:

Activity	Developer	Maia
Requirements	Defines the problem, the scope, and the acceptance criteria.	Helps turn an idea into a scope, epics, and user stories.
Architecture	Decides on the module structure, integrations, and data model.	Proposes domain models and explains existing documents.
Building	Gives goals and context, reviews and refines generated documents, and models parts by hand when needed.	Creates and changes documents, and recommends next steps in the editors.
Review	Checks each generated or changed document, and decides what to keep.	Shows the list of changed documents, and explains its changes on request.
Quality and security	Owns the quality, security, and performance of the app.	Detects anti-patterns and helps solve consistency errors.
Delivery	Commits the changes, and deploys and operates the app.	Summarizes logs and organizes feedback for the next iteration.

From Assistance to Agents

Maia offers a range of capabilities, from assistance with single steps to agentic work. Each level gives Maia more responsibility for a task. At each level, you review and approve the result.

Level	What Maia Does	Examples
Guidance	Answers questions and explains concepts or existing documents. Maia does not change your app.	Chat with Maia Maia Learn Maia Explain
Recommendation	Suggests the next step in the editor that you have open, or detects issues in your app model. You decide which suggestion to apply.	Logic Recommender UI Recommender Workflow Recommender Best Practice Recommender
Generation	Creates or changes one or more documents based on your request.	Start with Maia Maia Make
Agentic development	Carries out a goal that involves several steps or documents. It can ask clarifying questions and use tools, such as external MCP servers or web content.	Maia Make with Maia MCP Client and Maia Web Fetch External agents through the Studio Pro MCP Server

Choose the level that fits the task. For a small change in a microflow, a recommendation is often faster than a conversation. For a new feature that affects several documents, give the goal to Maia Make or to your own agent.

Working Practices for Agentic Development

The following practices help you get reliable results from Maia and other agents, and keep control of your app.

Start with Clear Intent

Describe the outcome you want and the context in which it is used. If you work with user stories, use them as input. Maia Make supports story-based development and can generate app artifacts from existing user stories. For larger initiatives, use Maia Plan to define the scope and solution before you build.

For guidance on how to write effective prompts, see Prompt Engineering and the Best Practices section of Maia Make Capabilities.

Give the Agent the Right Context

Maia uses your app model as context. You can add more context in the following ways:

Documents – Add the relevant microflows or pages to the conversation with the @ option, or from the App Explorer.
Attachments – Attach images, PDFs, Markdown documents, or user stories.
Agent instructions – Use AGENTS.md files for context that applies to every conversation in a project or module, such as company conventions.
Agent skills – Use agent skills for knowledge that applies only in certain situations, such as your microflow conventions.

Agent instructions and agent skills follow industry standards, so they work with Maia and with other agentic tools.

Work in Small Steps

Agents give faster and more reliable results for focused, well-scoped goals. Split a large feature into smaller requests, for example, first the domain model, then the pages, then the logic. Review the result of each step before you continue.

Review Every Change

After Maia completes a request, review the result:

Open each document in the list of changed items above the chat box.
Check the documents in their editors.
Check the Errors pane for consistency errors.
If a change is not what you want, ask Maia to fix it. You can also undo the change per document or for all documents, and refine your request.

You can also ask Maia to explain its changes. Review changes from an external agent in the same way, in the Studio Pro editors and the Errors pane.

Use Version Control as a Safety Net

Commit your work before you give an agent a large task. Commit the changes after you have reviewed them. This gives you a clear point to return to. For more information, see Version Control.

Check Quality Continuously

Run Best Practice Recommender on generated documents in the same way as on documents that you model yourself. Test the generated functionality before you deploy it.

Capture Team Knowledge

When you correct an agent for the same reason more than once, write the correction down as an agent instruction or an agent skill. In Studio Pro 11.15 and above, you can ask Maia to create or edit a skill directly in the chat. Because agent instructions and agent skills follow industry standards, other agentic tools that your team uses can apply the same knowledge. Skills and instructions are stored in the skillssource directory of your app, so they stay with the app instead of with one developer. Module-level skills are also exported together with their module.