Logic Authoring
Overview
Logic Authoring is the authoring agent for Logic Fabric on Microsoft Dataverse. You describe what you want in plain language, and it generates the corresponding Logic Fabric artifacts, validates them, grounds every reference against your live Dataverse schema, and creates them directly on your project, one artifact at a time or a full multi-artifact suite from a single brief.
It is the one agent in the suite that writes. Where Logic Guard, Logic Context, Logic Insights, and Logic Assurance read the artifacts you have built and project them into governance, documentation, intelligence, and tests, Logic Authoring is the ingress: it lets a requirement enter as business language and become a governed declarative artifact, the executable source of truth the other agents then read.
Every artifact it produces is grounded against the running implementation, not a description of it. It references only entities, fields, option-sets, and sub-artifacts that actually exist, because it resolves every reference against your live Dataverse metadata before it writes. Nothing is created without your approval.
The problem it solves
Building on a low-code platform still means knowing the grammar. To create a formula you need its expression syntax; to create a decision table you need the right column count; to wire a flow you need the real input and output signatures of every block it calls; to target an entity you need the exact logical names of its fields and option-sets. A maker holds all of this in their head, and still makes mistakes, a fabricated field name, a validation with no message, a flow that calls a block that does not exist yet.
Logic Authoring turns "describe what you want" into "it exists, and it is correct." It carries the grammar for every artifact type, plans multi-artifact work in dependency order, grounds every reference against the real schema, and repairs its own output until it passes a bank of structural and semantic checks, before anything is written. The result is an artifact that is valid and grounded on the first create, not a draft you have to fix.
What it produces
| Deliverable | What you get |
|---|---|
| A single artifact | One artifact generated from one plain-language description, validated, grounded, and created live |
| A full multi-artifact suite | A complete set from one brief, planned as a dependency graph and built leaves-first so every reference resolves |
| Grounded metadata | Every entity, field, option-set, and sub-artifact reference linked to something that actually exists, never fabricated |
| A reviewed change | The enriched plan and every create or update are yours to approve; edits show a before/after diff |
| Reuse, not duplication | An existing artifact that already does the job is reused, confirmed by its behaviour, not just its name |
Grounded, not generated in a vacuum
The defining property of Logic Authoring is that it is grounded. A general model can write plausible-looking metadata that references account.creditlimit when the real field is new_credit_limit, or invokes a block that was never built. Logic Authoring does not. Its grounding engine resolves every reference against your project's live Dataverse metadata and real artifact signatures and rewrites the output to the real names, deterministically, and its verifiers reject anything that still does not hold. It links; it does not fabricate.
Who it is for
- Makers who want to build an artifact by describing it, and have it land correct and grounded.
- Functional consultants who capture a requirement and want it to become running logic without hand-writing FoL.
- Solution architects who need a whole suite, blocks, flows, a process, and its events, planned and built in dependency order from one brief.
- Teams standardizing on AI-assisted build who need generation that is safe: grounded, validated, reused where possible, and always approved before it writes.
How it fits the platform
Logic Authoring builds the artifacts that run in Logic Composer and Logic Process Orchestrator, and it writes them through Logic Assist (the MCP server) on your behalf. It is the front door of the platform's agentic loop: it authors the governed source of truth, and the reading agents project that same source of truth into documentation, governance, intelligence, and tests, without anything drifting from the running implementation.
Explore Logic Authoring
| Page | Contents |
|---|---|
| How It Works | The authoring fleet, the generate → validate → repair loop, and the plan → reuse → build orchestrator |
| Artifact Types | The 13 artifact types across five families, and what each generator produces |
| Configuration & API | Authoring modes, bring-your-own model and provider, per-project settings, and the REST surface |
Ready to run it? See the Installation guide.