Blog by Ontology Labs Request a demo
AI-native Mendix™ delivery

Your AI can't read your Mendix™ app.
mxto reads all of it.

The AI delivery engine for Mendix™ — no Modeler in the loop. mxto reads any app, authors every construct type, then compiles, deploys and tests it to a running app.

~29 → 0  Your AI makes ~29 guesses to read one Mendix™ microflow. mxto makes zero — and round-trips the whole app with zero diffs.

See it build an app → Request a demo
your-agent — mxto
$ mxto extract ./your-app Read complete (sub-second) ├── 4,162 microflows — in order, by name ├── 1,776 entities · 100% coverage └── 0 IDs to chase
Full build walkthrough — video soon
94.4%
Fewer tokens per flow
70/70
Construct types certified
4,967
Round-trip ops — 0 diffs
20s
To a healthy Mendix™ app

Reads any Mendix™ app. Writes the whole thing. Ships it running. No Modeler.

Delivering Mendix™ work end-to-end takes three things an AI usually can't do. mxto does all three — headless, on Mac, Linux and CI.

Reads it

Understands any Mendix™ app the way an LLM needs to — in order, by name, not as a tangle of opaque references.

94.4% fewer tokens than the Mendix™ SDK graph
47× faster extraction · 99.73% coverage

Writes it

Authors every construct type — entities, microflows, pages, security — and proves it didn't break anything.

70/70 construct types certified
0 diffs across 4,967 round-trip ops · 6,122 live ops

Ships it

Compile → deploy → test → a running app, with Mendix's own build tools. No Studio Pro.

mxbuild → MX 8–11 healthy in 20s
22-tool live debugger with semantic breakpoints

We measured what it costs an AI to read one Mendix™ microflow.

The Mendix™ SDK graph makes your AI resolve ~29 opaque references before it understands one flow. mxto reads the same flow in order, by name — zero resolutions.

29 guesses, or zero.
What your AI reads today — the SDK graph
2,592
tokens
~29
resolutions
// one flow = a bag of nodes wired by opaque IDs "startNodeId": "2693b9bf-cf9d-49e1-…" "edges": [ { "originNodeId": "f6167db7-5289-…", "destinationNodeId": "11aabc75-9ac7-…", "caseValue": "true" }, … 8 more edges, each a pair of IDs … ] // no order to read · no inline names · // ~29 resolutions before the logic is even seen
What your AI reads with mxto — in order, by name
145
tokens
0
resolutions
flow ApproveRequest(Request): if not Request.Status in (Submitted, InReview): show_warning("Only submitted requests…") return Request.Status = Approved Request.Reviewer = CurrentUser commit(Request) call(CreateAuditEntry) close_page() # read top-to-bottom · 0 IDs to chase
94.4%
fewer tokens (17.9 : 1)
~29 → 0
inference steps per flow

Measured on a real microflow with tiktoken o200k_base; resolution counts computed from the graph's own node/edge structure. The per-flow SDK graph is already a cleaned extraction — a conservative, SDK-favourable baseline. It compounds at estate scale: one production estate carries 4,162 flows.

The only tool that does all of it.

AI-for-Mendix™ approaches each do a piece — read a model partially, or suggest changes a human re-enters by hand, or generate code that can't be put back. Delivering work end-to-end needs every piece in one closed loop.

What end-to-end delivery needs Other approaches mxto
Read a Mendix™ model an LLM can use Partial — lossy or token-heavy ✓ 100% read coverage, 94.4% fewer tokens
Author every construct type × suggestions a human re-enters ✓ 70/70 certified, committed to Team Server
Run headless — no IDE, Mac/Linux/CI × tied to Studio Pro on Windows ✓ no Modeler at any step
Close the loop to a running, tested app × stops at code or a diff ✓ compile → deploy → UAT, verified
Prove the change didn't drop anything Hope — no measured drift ✓ 0 diffs across 4,967 round-trip ops

No IDE. Every construct type. A closed loop to a running app. Comprehension built for the LLM.

Your AI agent, finally fluent in Mendix™.

A Mendix™ model is a binary file your agent can't open. mxto is the toolchain it drives — 142+ tools, a clean CLI, and a comprehension layer built for an LLM. Bring Claude Code, Cursor, your own — mxto is how it reaches Mendix.

your-agent — mxto
$ mxto extract ./your-app Read complete (sub-second, 99.73% coverage) ├── 4,162 microflows — read in order, by name ├── 1,776 entities with associations └── 100% read coverage (zero transform failures) # the agent now reasons over the whole app — 142+ tools > "add a refund workflow and ship it" mxto ✓ authored entity + microflow + page + security (70/70 types) ✓ mxbuild Mendix's own build tools → MDA ✓ deployed MX 11 app server — healthy in 20s ✓ UAT XAS + browser checks green — 0 unexpected diffs

Proven, not promised.

Every claim above is measured against real production Mendix™ apps — read fidelity, write coverage, and the round-trip that proves nothing dropped.

70/70
Construct types certified — read 100% + write 100%, 0 non-automatable
4,967
Round-trip operations — 0 unexpected diffs on a real production estate
48,385
Logic expressions parsed at 100% · 6,122 live model operations
MX 8–11
Healthy in 20 seconds · live debugger with semantic breakpoints

mxto reads and visualises every layer of a Mendix™ app — these are real outputs from a production application built end-to-end by Claude Code.

Complex Mendix microflow with nested loops rendered from mxto's semantic extraction
Enterprise microflow with nested loop structures, decision branches, and 14 top-level nodes — rendered from zero-loss semantic extraction
Asset
AssetTag String
Name String
Category Enum
SerialNumber String
PurchaseCost Decimal
IsActive Boolean
Request
RequestNumber AutoNumber
Title String
Status Enum
Priority Enum
RequestDate DateTime
ReviewNotes String
AuditEntry
Action String
Timestamp DateTime
OldValue String
NewValue String
ChangedBy String
Comment
Text String
CreatedDate DateTime
Notification
Message String
Type Enum
IsRead Boolean
CreatedDate DateTime
Enumerations
RequestStatus 5 values
Priority 4 values
AssetCategory 5 values
Department 5 values
NotificationType 4 values
→ Request — Asset (equipment linked to request)
→ Comment — Request (discussion thread)
→ AuditEntry — Request (state change log)
→ Request — Requester [User] (who submitted)
→ Request — Reviewer [User] (who approved/rejected)
→ Notification — Request (status change alerts)
→ Notification — Recipient [User] (target user)
Entity / Action User Manager Admin
Asset — Read Active only All All
Asset — Create/Edit/Delete — — Full CRUD
Request — Read Own only All All
Request — Create Yes Yes Yes
Request — Approve/Reject — Yes Yes
AuditEntry — Read — Yes Yes
AuditEntry — Delete — — Yes
Bulk Approve — Yes Yes
Export CSV — Yes Yes
Dashboard Metrics Own stats All stats All stats

Built by AI. Verified by proof.

Claudius is a complete Mendix™ application authored end-to-end through Claude Code driving mxto — no Studio Pro in the loop.

Claudius: IT Asset & Request Tracker

A production-quality Mendix™ 10 application built from YAML specifications by Claude Code. Not a toy demo—a real application with approval workflows, audit trails, role-based access control, REST APIs, and SOAP integration.

Every entity, microflow, page, and security rule was authored by AI using mxto, then compiled, deployed and tested headless. The entire build is reproducible from specification files.

  • Request approval workflow (submitted → review → approved/rejected → completed)
  • Audit trail system with before/after commit event handlers
  • Role-based access control (User, Manager, Admin)
  • Published REST API with export mappings
  • Consumed SOAP web services for external integration
  • Scheduled events for automated processing
  • Nanoflows for client-side logic
  • 3-phase test harness: 21 basic + 16 advanced + stress tests
Claudius — Analysis Summary
Microflows 38
Entities 5
Enumerations 5
Associations 7
YAML Spec Files 8
Action Microflows 16
Data Sources 8
REST Operations 3
Scheduled Events 3
Nanoflows 4
Build Method Claude Code + mxto

Validated at production scale.

mxto has been read-certified across 8 production Mendix™ estates spanning financial services, agritech, workforce, lending and hospitality — with zero transform failures.

Enterprise estate

Financial services
4,162 microflows • 1,776 entities
48,385 logic expressions parsed at 100%

Write path, live

Round-trip proven
6,122 live model operations • 0 unexpected diffs across 4,967 round-trip ops

Claudius (AI-built)

Demo — IT asset management
38 microflows • 5 entities • 8 spec files
Built entirely by Claude Code via mxto

Built right is not the same as means right.

structurally safe → semantically correct

mxto makes AI-in-Mendix™ structurally safe — the app builds, the model round-trips, nothing drops silently. But a structurally-valid app can still be semantically wrong. Making an app mean what you intend is the next layer — the semantic work we do at Ontology Labs.

See the semantic layer →

Put an AI delivery engine
on your Mendix™ estate.

Today your AI is effectively blind to your Mendix™ estate — one microflow costs it ~29 guesses, so whole-app comprehension stays out of reach and the work stays manual. mxto changes what your AI can do with Mendix™. We'll prove it against a sample of your own estate — no Studio Pro required.

Prefer to evaluate first? Read the machine-readable AI evaluation, reproduce the benchmark, or email hello@ontologylabs.ai. Learn about AYIOS →