AIDE Pro documentation

Overview

AIDE Pro is an extension for Mendix Studio Pro 11 that exposes your application model to an AI coding agent as tools. The agent reads the whole model and creates real Mendix artifacts - entities, microflows, pages, security, integrations - then verifies them using the platform’s own checks.

It is not a chat assistant, and understanding that distinction is the fastest way to understand the product. AIDE Pro contains no chat window, no conversation history, no AI provider settings and no API keys. It never calls a language model. Your agent - Claude Code, Cursor, GitHub Copilot, Antigravity or your own client - brings the model and the credentials; AIDE Pro executes model operations and reports what actually happened.

Which edition these docs describe

There are two editions of AIDE Pro, and this documentation describes the Mendix 11 edition - the one that exposes 243 tools to an external AI coding agent over MCP.

Why Mendix needs this

On a text codebase an AI agent can simply write the file. A Mendix application is not a folder of source files: it is a structured model stored in an .mpr file. So an AI chat assistant can only describe the microflow you asked for, leaving a person to build it by hand, which is where the time actually goes.

AIDE Pro turns those descriptions into operations. When a tool call returns, the artifact exists.

Why not just let an agent edit the .mpr?

Because it can, and that is the problem. The .mpr is a SQLite database whose per-document content lives in BSON files under mprcontents/, so a capable agent can read it and write to it without any help. What it cannot do that way is change it safely.

Direct writes skip everything the platform would have done for you:

• No validation. Mendix has strict consistency rules. Logic that reads perfectly well can be unbuildable, and a direct write never asks.
• No transaction. A half-applied change stays half-applied.
• No referential care. Documents, folders and their content files reference each other by id. Break one link and the model is inconsistent in a way nothing surfaces.

AIDE Pro writes through Mendix’s own model APIs instead - the same ones Studio Pro uses when you click - so changes are validated and transactional, and then it checks the result. That is the difference between an agent that can reach your model and an agent that should.

What it gives an agent

Who it is for

• Mendix teams already using an AI coding agent who want it to do more than talk about the app.
• Teams with a large or unfamiliar Mendix codebase that need to search, map and audit it quickly.
• Teams under governance constraints that need the AI layer to hold no credentials and send nothing anywhere.

What it does not do

AIDE Pro does not replace developer review. A model that passes the consistency check is buildable, not necessarily correct - the check validates structure, not your business rules. Treat the agent as a fast, tireless builder whose work you still read. The known limitations section lists the specific gaps, and it is deliberately blunt.

Requirements

You need Mendix Studio Pro 11, an MCP-compatible AI coding agent, and a Windows machine to run them on. AIDE Pro installs per application.

Per-application installation

AIDE Pro is an app-level extension: it installs into an individual Mendix application, not once per workstation. Each application you want an agent to work on gets its own installation, and it travels with that project directory.

Studio Pro must be open

AIDE Pro works on the model that Studio Pro currently has open, and part of the tool surface executes inside the extension’s own pane. That means Studio Pro stays open, with the AIDE Pro pane open, while your agent works. The pane also shows whether the bridge is live, which is the first thing to check if your agent reports no tools.

A note on unsaved editor tabs

A document open and unsaved in a Studio Pro editor tab withholds its changes from the .mpr file. Consistency checks read what has been written, so an unsaved tab can make a check look clean while the model is not. AIDE Pro reports the file’s last write time alongside consistency results so you can spot this; if it looks stale, save in Studio Pro and re-run.

Getting AIDE Pro installed

AIDE Pro is distributed by Golden Earth with a setup guide for your environment. This page describes the shape of the installation so you know what to expect and what to check.

1. Get the distribution. Talk to our team and tell us your Mendix version and which AI agent your developers use. You receive a versioned package plus setup documentation covering the exact steps for your setup.
2. Install into the application. The package places the extension inside the Mendix app directory. Because it is app-level, this is per application - see Requirements.
3. Start Studio Pro and open the app. AIDE Pro appears as a dockable pane. Open it and leave it open: part of the tool surface runs there, and the pane is what tells you the bridge is live.
4. Connect your agent. Point your MCP client at the local bridge - see Connect your agent. On connection the agent receives the full tool list.
5. Confirm with a read-only call. Before letting an agent write anything, have it list your modules. If that returns your real module names, the whole path works.

What gets installed

Upgrading

Upgrades replace the extension in the application. Close Studio Pro first - files in use cannot be replaced - then install the new version and reopen. Because agent instruction files are regenerated on install, project-specific rules belong in your own always-on file at the project root (for example CLAUDE.md, AGENTS.md or .cursor/rules/), which survives an upgrade.

Connect your agent

AIDE Pro runs a local MCP server. Any Model Context Protocol client connects to it the same way, and receives the full Mendix tool list on connection.

The bridge listens on loopback only and rejects browser-originated requests, so the tools are reachable from agents running on that machine and not from the network. The exact endpoint is written into the project when AIDE Pro starts, and the setup guide that ships with your distribution gives you the precise configuration snippet for your client.

Claude Code

Claude Code registers AIDE Pro as an MCP server, then treats the Mendix tools like any others. It suits longer Mendix work because it plans multi-step changes, calls tools in sequence, and reacts to the consistency errors the tools hand back - so a rejected write usually gets fixed inside the same session rather than surfacing at your next build.

Cursor

Add AIDE Pro under Cursor’s MCP server settings and the Mendix tools become available in the editor you already use, alongside your own rules and prompts. This is what makes it possible to work on a Mendix app from Cursor at all: without a tool layer, Cursor sees an .mpr file it cannot open.

GitHub Copilot, Antigravity and other MCP clients

Nothing in AIDE Pro is specific to one vendor. It advertises its tools over standard MCP, so GitHub Copilot and Antigravity connect the same way as the two above, as does a custom in-house agent or a client that does not exist yet. Antigravity is worth one note: its MCP config key is serverUrl rather than url, which is easy to miss.

Confirming the connection

1. The pane says connected. Open the AIDE Pro pane in Studio Pro. It reports whether the bridge is live. If it is not, no client will find tools.
2. Your client lists the tools. A connected client shows the Mendix tools in its tool list. A client that connects but lists nothing normally means the pane is closed.
3. A read-only call returns your app. Ask the agent for your module tree. Real module names mean the whole chain works - client, bridge, extension, open model.

Tool loading

An MCP client receives every tool on connection, which is what you want for a coding agent: it can plan across the full surface without asking for more. Clients that prefer a smaller starting set can use a tiered mode, where a core group is always present and the rest is grouped into categories the agent requests by name when it needs them.

How it works

Your agent connects to a local bridge inside Studio Pro. The bridge routes each tool call to whichever half of the extension implements it, the operation runs against the open model, and the result comes back as text the agent can act on.

Two tool registries, one interface

AIDE Pro is implemented in two halves because Mendix exposes its model through two different APIs. Your agent does not need to care - every tool looks the same over MCP - but it explains one operational rule.

What a tool call actually does

1. Validates the arguments. A required field that is missing or empty is refused before anything is modified, with a message naming the field.
2. Resolves everything first. Tools that act on several items resolve every name up front, so a typo in the third name cannot leave the first two half-applied.
3. Runs inside a transaction. The change is applied through Mendix’s own model APIs, the same ones Studio Pro uses when you click.
4. Reads the result back. The tool re-reads what was stored and reports that - not a restatement of the request. Properties the platform silently dropped show up here.
5. Returns text, plus any rules that apply. Results can carry short “learnings”: hard-won notes about the specific operation the agent just performed. See Skills and learnings.

No AI model in the loop

AIDE Pro contains no model client, no provider configuration and no credential storage. It cannot call a language model even if you wanted it to. Everything intelligent happens in your agent; everything Mendix-specific happens in AIDE Pro. That split is why there is nothing in the extension to leak - see Security.

Tools and capabilities

AIDE Pro currently exposes 243 tools. They are grouped below the way a developer thinks about the work rather than by which half of the extension implements them, because from your agent’s side that distinction is invisible.

Every tool reports what it actually did. Writes are followed by a read-back, and wide-reaching operations refuse ambiguous input rather than guessing - a missing folder path, for instance, is an error rather than a silent move to the module root.

Domain model

Entities, attributes, associations including cross-module ones, enumerations, indexes, validation rules, persistability and system members. Also OQL-backed view entities end to end: create the entity, set the query, sync it, and map columns and associations.

create_entity · create_attribute · create_association · create_cross_association · create_enumeration · add_enum_value · add_index · add_validation_rule · set_entity_persistability · create_view_entity · set_view_entity_oql · sync_view_entity · analyze_domain_model

Microflows and logic

Whole microflows or individual activities, with real flow control: decisions, loops, merges, break and continue, inheritance splits and error handlers. Retrieve, create, change, commit, aggregate and list operations, microflow and Java action calls, REST calls, messages, logging and validation feedback.

create_microflow · add_activities_to_microflow · edit_microflow_activity · add_decision · add_loop · add_error_handler · add_microflow_call · add_rest_call · add_log_message · get_microflow_details · tidy_microflow_layout

Pages and UI

Pages, layouts, snippets and building blocks; data views, list views, input widgets, tab containers and buttons; data sources, attribute bindings, on-click actions, conditional visibility and CSS classes. Includes generated CRUD pages, and Data Grid 2 and Combo Box built without needing a donor page to copy from.

create_page · add_widget_to_page · configure_widget · set_widget_caption · move_widget · generate_crud_pages · create_datagrid2 · create_combobox · create_layout · create_snippet · get_page_structure

Security

Application security level and strict mode, user roles and the module roles they map to, per-role home pages, page and microflow access, and entity access rules with row-level XPath. Readable as well as writable, which matters: project security was previously write-only, so nothing could audit it.

get_project_security · set_security_level · add_user_role · set_user_role_module_roles · create_module_role · get_access_rules · add_access_rule · edit_access_rule · set_page_roles · set_microflow_roles · analyze_security

Integration

JSON structures, REST calls with body templates and headers, and import and export mappings including the element tree rather than only the schema reference.

create_json_structure · create_import_mapping · create_export_mapping · set_element_mapping · get_mapping_elements · configure_rest_call

Run, query and observe

Build and start the application, stop it, then query it while it runs: live OQL, runtime statistics, request traces and the runtime log. This is what turns “the data looks right” into a result set.

build_app · run_app · stop_app · run_oql · validate_oql · read_runtime_log · runtime_stats · runtime_requests · get_app_run_status

Analysis and navigation

Read-only analyzers and whole-model navigation: a call graph, usage search, a model index, and analyzers for security, performance, concurrency, dead code, UX and data-model quality.

check_consistency_errors · search_model · find_usages · get_call_graph · build_model_index · analyze_performance · analyze_concurrency · analyze_dead_code · analyze_ux · get_modules_tree · list_documents · inspect_element

Project structure

Modules, folders, document placement and moves, menus, navigation, workflows, constants and project settings. Documents can be placed in nested folders at creation and moved afterwards, so a generated module still looks like something a person would hand over.

create_module · create_folder · move_document · create_menu · configure_navigation · set_home_page · create_workflow · create_constant · edit_project_settings

Knowledge

The learnings store, plus the on-demand documentation and API lookups the agent uses to check itself against Mendix’s own reference material.

add_learning · list_learnings · search_mendix_docs · lookup_mendix_api · search_extensions_api · request_tools

Tool names and counts move as the product does. The authoritative list is whatever your connected agent reports on connection - ask it to list its tools.

How the agent verifies its work

This is the part that separates a useful agent from a merely fast one. AIDE Pro makes the agent check itself inside the platform before it reports success, and it exposes the difference between the layers so a passing check means something.

The four layers

1. Read-back. Every write is followed by a read of what was actually stored, not a restatement of what was requested. Nested properties the platform silently declined to persist surface here and nowhere else.
2. Consistency check. Mendix’s own error list - the same one Studio Pro shows you - with real error codes. Unbuildable logic is caught in seconds rather than at your next deployment.
3. Live query. With the application running, the agent can execute OQL against it and read the runtime log, so a claim about data becomes a result set.
4. Reload. Closing and reopening the app is the only operation that reads every stored file. It is the strongest check available, and the one worth using after anything that removed or re-parented a document.

Why this is in the product, not just the manual

We learned it the hard way. An early version of one tool moved documents by removing and re-adding them, which deleted a file on disk and left the project unopenable - while the model tree, the consistency check and the tool’s own read-back all reported success, because every one of them was reading memory. The tool was rebuilt on the operation Studio Pro itself uses for moves, and the lesson is now shipped as a rule the agent receives.

Consistency-clean is not correct

The consistency check validates structure, not intent. It will confirm a microflow is buildable; it has no opinion on whether the logic matches your business rules. Two failure modes are worth knowing about specifically:

• Present is not reachable. An artifact can exist in the model and still never execute, because nothing calls it or no role can reach it. Verify on the executing path, not just in the tree.
• Green is not runtime-valid. Some writes pass every check and still fail at runtime because a companion field the runtime requires was never set.

What to ask your agent for

The habits that make agent output trustworthy are cheap to request explicitly:

• “Run the consistency check after every document you create or edit, and fix errors before moving on.”
• “Read back what you wrote and show me the stored values, not your intent.”
• “If you cannot verify something, say so rather than reporting success.”

Rules like these can live in your agent’s always-on project file so you do not have to repeat them - see Skills and learnings.

Skills and learnings

AIDE Pro carries two kinds of knowledge into your agent’s context: skills, which are reference material the agent loads when a topic comes up, and learnings, which are short rules attached to specific tools and delivered at the moment they apply.

Learnings: rules delivered exactly when they matter

A learning is a compact note linked to one or more tools. When the agent calls a tool that a learning is attached to, the rule arrives with the result. This is deliberately different from a large system prompt: the guidance shows up at the point of use, when it is relevant and cheap, rather than competing for attention up front.

They exist because Mendix has behaviours no type signature warns you about. Genuine examples that ship with the product:

• Some attribute names collide with inherited system members and are rejected at runtime rather than at creation.
• Entity access rules are unioned, so narrowing one requires editing it rather than adding a tighter rule beside it.
• A document open and unsaved in a Studio Pro editor tab withholds its changes, which can make a consistency check look clean.
• Moving documents by remove-then-add corrupts the project; the platform’s own move operation is the one to use.

Skills: deeper reference, loaded on demand

Skills are longer documents covering one area each - the microflow API and its traps, domain-model behaviour, page and widget quirks, reserved names, the tool inventory and routing. Your agent reads the one it needs instead of carrying all of them all the time.

AIDE Pro writes these into the project in the formats the common agents expect, so whichever client your team uses picks them up without configuration.

Your own project rules

Team standards - naming conventions, module structure, review expectations - belong in your agent’s own always-on file at the project root: CLAUDE.md, AGENTS.md, .cursor/rules/, or whichever your client reads.

Adding learnings as you go

When your team discovers something non-obvious about your application - a module that must be touched in a particular order, an integration with a quirk - it can be recorded as a learning so later sessions receive it automatically. Keep them for hard-won, non-obvious knowledge; a store full of restated documentation is noise, and noise gets ignored.

Context and scope

How much of your application the agent is given matters. A large Mendix app contains far more model than any context window should carry at once, so AIDE Pro controls both the breadth and the depth of what gets described.

Context depth: how much of the app

Context mode: how much detail

Discovery tools do the heavy lifting

Rather than describing everything in advance, the agent finds what it needs:

• get_modules_tree - the whole module, folder and document tree in one call. The usual first orientation step.
• search_model - find anything by name or content across the application.
• find_usages and get_call_graph - what calls this, and what does it call. Essential before changing shared logic.
• build_model_index - a fuller index for repeated navigation of a big app.
• get_entity_details, get_microflow_details, get_page_structure - deep detail for one artifact when it is actually needed.

Scoping work in practice

The most reliable pattern on a large application is to let the agent orient itself first and then constrain it: ask for the module tree, agree which module the work belongs in, and say so explicitly. That beats both extremes - a blind agent guessing where things go, and an agent handed the entire model and asked to be careful.

Security and data handling

AIDE Pro calls no AI model, stores no credentials, and sends nothing anywhere. There is no data-handling policy to negotiate about the extension itself, because it has no outbound path.

What AIDE Pro does not have

Where your data actually goes

This is the honest boundary, and it is worth being precise about: AIDE Pro sends nothing, but your agent does. When your agent decides to call a tool, whatever it has read about your model is in its context, and that context goes wherever its model is hosted.

The bridge

The tool bridge listens on loopback only. Two properties matter for review:

• Loopback binding. Requests from other machines cannot reach it.
• Browser rejection. Requests that look like they originate from a web page are refused, so a page you visit cannot quietly drive your Mendix model.

What the agent can change

Be clear-eyed about capability: an agent with AIDE Pro connected can modify your application model, including its security configuration - user roles, page and microflow access, and entity access rules. That is the point of the product, and it is also a real consideration.

Deployment surface

AIDE Pro runs where Studio Pro runs: a developer workstation or a controlled build environment. It adds nothing to your deployed application - it is a development-time extension, and nothing about it ships to your production runtime.

Known limitations

This list is deliberately blunt. Knowing where the tools stop is more useful than a longer feature list, and every item here is something we hit ourselves.

Platform gaps

Behaviours that surprise people

• Snippets drop configuration. Widgets added to a snippet keep simple captions but lose data sources, actions and bindings. Keep snippets static and build data-bound widgets on pages.
• Unsaved editor tabs hide changes. A document open in a Studio Pro tab withholds its changes from the file, so a consistency check can report clean while the model is not. Save, then re-check.
• Access rules are additive. A tighter rule added next to an over-broad one changes nothing. The broad rule must be edited.
• Reserved attribute names. A few names collide with inherited system members and fail at runtime rather than at creation.
• Some creates need a second call. Certain properties do not persist at creation and have to be set afterwards. The tools do this for you where it is known, and read back so you can see what landed.

The limitation that is not ours

Version drift

AIDE Pro is built against the Mendix Extensions API, which changes between releases. Capabilities can appear or move as Mendix evolves the API, so this list is accurate for the current release and reviewed for each one. The distribution you receive ships with release notes covering what changed.

Troubleshooting

Most problems are one of four things: the pane is closed, the wrong application is open, a document is unsaved, or the agent is being told about a tool it does not have. This page is ordered by how often each turns out to be the cause.

My agent connects but sees no tools

1. Open the AIDE Pro pane. Part of the tool surface runs there, and the pane is what reports whether the bridge is live. A closed pane is the single most common cause.
2. Check which app Studio Pro has open. AIDE Pro works on the currently open application. If a different one is open, the tools operate on that instead.
3. Confirm the install is in this application. AIDE Pro is installed per app. An app you have not installed it into has no bridge at all.

Some tools work and others do not

This pattern almost always means the pane is closed while Studio Pro is open. The in-process half of the tool surface keeps working - microflows, security, search, build and run - while the pane half stops: pages, entities, associations, enumerations. Open the pane and retry.

The consistency check says zero errors but the app is wrong

• Check for unsaved editor tabs. An open document withholds its changes from the file. Compare the reported file write time against when the change was made; if it is older, save in Studio Pro and re-check.
• Remember what the check covers. It validates structure, not your business logic. A buildable microflow can still do the wrong thing.
• If documents were removed or moved, reload. Consistency checks read the in-memory model, so damage to stored files is invisible to them. Close and reopen the application - that is the only operation that reads every file.

The agent says it made a change and I cannot find it

1. Ask it which module and folder. Documents can be created in nested folders, so it may simply not be where you looked.
2. Get the module tree. get_modules_tree shows the full folder and document structure in one call.
3. Refresh Studio Pro’s view. The Project Explorer does not always repaint immediately after a programmatic change.

A tool refuses my request

Refusals are usually deliberate, and the message says which field is at fault. Tools reject ambiguous input rather than guessing - a blank folder path, for example, is an error instead of a silent move to the module root, and a batch operation with one bad name refuses the whole batch rather than half-applying it. Read the message before retrying: a retry with the same arguments will refuse again.

Live queries fail

Live OQL and runtime tools need the application to be running. If it is not, they will say so. Start the app first, and note that a rebuild invalidates an existing browser session and interrupts log capture, so re-establish those after a restart.

Studio Pro becomes unresponsive

Model operations run on Studio Pro’s UI thread, so a large batch can make the interface pause. AIDE Pro can report whether the UI thread is responsive, which distinguishes “still working” from “stuck”. If an operation has been running far longer than it should, that is worth investigating rather than waiting out.

Still stuck

Contact our team with what you tried, what your agent reported, and your Mendix version. The tool output is usually enough for us to identify the cause, so include it if you can.