MCP Tool D365 Artifact Engine

The fastest way to build D365 F&O artifacts. Period.

generate_fo_artifacts

A 25-artifact requirement burns 50,000–140,000 tokens when an LLM builds D365 XML from scratch. Most of that is wasted on build-fail-fix retries. One generate_fo_artifacts call: ~1,000 tokens. Zero retries. 9.82/10 certified accuracy across 27 production requirements.

27/27 Certified · 9.82 Mean Accuracy · 70–100× Fewer Tokens

Get Your API Key See What It Generates Setup Guide

Token Economics

70–100× Fewer Tokens. Here’s the Math.

Every time an LLM generates a D365 artifact from scratch, it pays three hidden costs — and the retry loop alone costs more than everything else combined.

Schema Context 5–15K tokens/call

D365 XML schema refs, folder conventions, namespace rules — injected into the prompt every single call. generate_fo_artifacts: zero. 23,732 lines of encoded knowledge built into the engine.

Raw XML Output 15–25K tokens

The LLM generates full XML text token by token — often structurally wrong on the first attempt. generate_fo_artifacts: server-side generation, ~200 token response summary.

Retry Loops 3–10 cycles × 8–22K each

Build → read error log → re-prompt with error context → re-generate → build again. This cycle consumes 60–80% of the total token budget. generate_fo_artifacts: zero retries needed.

LLM from scratch 50,000–140,000 tokens

generate_fo_artifacts ~1,000 tokens

Per 25-artifact requirement (table + form + security stack). Source: S1 Certification Campaign, 27 requirements, mean accuracy 9.82/10.

The Problem

XML Scaffolding Wastes 80% of Your AI Token Budget

A simple “add a new entity with a form and security” means 10–15 XML files. Without generate_fo_artifacts, your AI agent spends 50,000–140,000 tokens on each one — and 80% of those tokens are wasted on build failures, error parsing, and retry attempts.

MANUAL

Developers Spend 30–60 min on Boilerplate

Experienced developers hand-craft AxTable, AxEdt, AxEnum, AxForm, AxMenuItemDisplay, AxSecurityPrivilege XML — each with its own schema and naming conventions — before writing a single line of business logic.

AI AGENT

AI Agents Hallucinate XML Structure

Without exact XML schema knowledge, coding agents hallucinate element names, nest nodes incorrectly, and produce artifacts that fail on first build. The fix-loop burns tokens: read error, guess fix, rebuild, repeat.

COST

50,000–140,000 Tokens per Requirement

That’s not development — that’s your AI budget burning on plumbing. Structural scaffolding and its retry loops consume 60–80% of a development cycle’s token spend.

How It Works

Three Steps. Plain English In, Deployed Artifacts Out.

You describe what you need. Your AI agent handles the API call. The deploy script places files automatically.

1 →

Describe

Tell your AI agent what you need: “Create a VehicleTable with VehicleId, Make, Model, Year”

2 →

Generate

The agent calls generate_fo_artifacts — production-ready XML back in under 2 seconds

Deploy

The AI agent automatically runs the included deploy script to place files in your D365 metadata folder. Start writing business logic.

Under the Hood

A Structured API, Not a Prompt

Define your artifacts as typed task objects. The engine returns production-ready XML files with a deployment script.

What AI Sends

A model name, a prefix, and an array of task definitions. Each task specifies the artifact type and its properties.

input · tasks

{
  "model_name": "ContosoFleet",
  "model_prefix": "CFlt",
  "tasks": [
    { "type": "table",
      "name": "Vehicle",
      "fields": [
        { "name": "VehicleId", "type": "string", "size": 20 },
        { "name": "Make", "type": "string", "size": 60 }
      ] },
    { "type": "form",
      "name": "Vehicle",
      "style": "ListDetails" },
    { "type": "security_privilege",
      "name": "VehicleMaintain" }
  ]
}

→ < 2 sec

What You Get Back

Production-ready XML files ready to deploy to your metadata folder, plus a PowerShell deployment script.

output · files

CFltVehicle/
  AxTable/       CFltVehicle.xml
  AxEdt/         CFltVehicleId.xml
  AxForm/        CFltVehicle.xml
  AxMenuItemDisplay/ CFltVehicle.xml
  AxSecurityPrivilege/
                 CFltVehicleMaintain.xml
  deploy.ps1     # one-command deploy

Pass bare names like "Vehicle" and "VehicleId" — the engine prepends your model prefix to every AOT object and rewrites all internal references to match.

Artifact Coverage

15 D365 F&O Artifact Types

New objects and extensions of standard D365 objects — all from one API call

Table

AxTable with fields, indexes, relations

EDT

Extended Data Types for consistent fields

Enum

Enumerations for dropdowns and status

Form

UI forms with data sources and layout

Label

Label resource files for localization

Menu Item

Navigation items for form access

Data Entity

OData entities with staging tables

Privilege

Security privileges with EntryPoints

Duty

Security duties grouping privileges

Role

Security roles for access control

Extensions supported: Table Extension, Form Extension, Data Entity Extension, Field (companion definitions for tables and extensions)

Differentiators

What Makes It Different

Not just code generation — a deterministic artifact creation engine

Naming Is Automatic

Pass bare names like "Vehicle" and "VehicleId." The engine prepends your model name to every AOT object and rewrites all internal references to match. You never touch a model prefix manually.

Near-Zero Structural Errors

Output matches the D365 compiler schema by construction, not by trial and error. Cross-references between artifacts in the same batch resolve correctly. No dangling references, no missing namespaces.

Deploy Script Included

Every response contains a PowerShell script that copies the generated files to your metadata folder, preserving the D365 directory structure — AxTable, AxEdt, AxEnum, AxForm, and more.

Up to 500 Artifacts per Call

A complete module — tables, fields, EDTs, enums, forms, menu items, security stack, data entities — in a single request. Sub-2-second execution. Deterministic output.

The Numbers

Side-by-Side Comparison

A typical customization: new table, 8 fields, list-details form, menu item, maintain/view privileges, duty, and data entity (~20 artifact files)

Approach	Time	Build Errors	Token Cost
Manual XML by developer	30–60 min	2–5 typical	N/A
AI agent writing XML	5–15 min	3–10 typical	50,000–140,000
generate_fo_artifacts	< 2 sec	0	~1,000

Proven at Scale

Stress-Tested: 140 Files from a Single Call

The S1 Certification Campaign scored 27 production requirements. Mean accuracy: 9.82/10. 14 of 27 scored a perfect 10.0.

140

Files Generated

5 tables, 3 extensions, 4 forms, 4 data entities, full security stack — one call.

Structural Errors

Zero fixes needed. The Stage 2 validation agent made no changes to the output.

< 2s

End-to-End

An LLM from scratch? 200,000–500,000+ tokens across hours of retry cycles.

9.82

Mean Accuracy

Independently scored by an AI judge comparing output against Stage 2 validated production code.

Real Scenario

Add a Vendor Rating System

Track vendor quality ratings with a custom table, expose it on the vendor form, and make it available for import via data entity.

Without generate_fo_artifacts: Hand-craft 12+ XML files — AxEdt, AxEnum, AxTable, AxForm, AxMenuItemDisplay, security privileges, duty, a form extension for VendTable, and AxDataEntity — each with its own schema and naming rules. Build. Fix 2–5 errors. Rebuild.

With generate_fo_artifacts: Query fo-semantic to understand existing VendTable patterns (2 sec). Call generate_fo_artifacts with 15 tasks (2 sec). Deploy generated files (5 sec). Write X++ business logic (15 min). Build — clean first build (3 min).

75%

Time Saved

70–100×

Fewer Tokens

Structural Build Errors

Integration

Standalone MCP Tool + AutoXPP

Use it on its own to skip the XML grind. Or let AutoXPP call it for you as part of the full autonomous lifecycle.

Standalone

generate_fo_artifacts is a standard MCP tool. Connect it to Claude Code, Cursor, Windsurf, VS Code, Claude Desktop — any MCP-compatible client. No AutoXPP required.

Your AI agent calls it directly whenever it needs D365 artifacts — no orchestration framework needed. Free accounts included.

See monthly limits by plan ↓

With AutoXPP

AutoXPP subscribers get unlimited generate_fo_artifacts usage included in their plan. AutoXPP's coding skill calls it automatically on every structural work item — no metering friction during autonomous development cycles.

The structural layer that used to consume 40–60% of a development cycle now costs a single API call. The AI agent's full capacity goes to business logic.

AutoXPP = unlimited generate_fo_artifacts + full autonomous lifecycle

Subscribe to AutoXPP →

Knowledge Foundation

generate_fo_artifacts uses fo-semantic's 150,000-artifact knowledge base internally. The engine runs server-side with no local codebase — when it needs D365 structural knowledge, it queries fo-semantic. This is how it produces production-ready XML in under 2 seconds without requiring a local codebase.

Pricing

Monthly Limits by Plan

Every account starts with 5 free calls. Upgrade for higher volume or unlimited usage with AutoXPP.

Plan	Calls / Month
CloudForge Free	5
Artifact Engine ($9/mo)	500
CloudForge Foundation ($25/mo)	100
CloudForge Production ($99/mo)	500
AutoXPP Professional ($149/mo)	Unlimited

Get Started

Ready to Skip the XML Grind?

Free to start — 5 calls/month, no subscription required. Works with any MCP-compatible AI client.

Get Your API Key Setup Guide Explore AutoXPP for Unlimited Usage

Questions? contact@xplusplus.ai