How It Works
Logic Authoring is a grounded, neurosymbolic authoring fleet. Model generation is wrapped in symbolic verifiers and live schema-linking: the work is deterministic where correctness must be exact (grounding, structural and semantic validation) and agentic where interpretation and language are required (understanding intent, producing the metadata). It uses no fine-tuning, and it is model- and provider-independent.
Two loops sit at its core: a generate → validate → repair loop that self-heals each artifact before it is written, and a plan → reuse → build orchestrator that turns a multi-artifact brief into a dependency-ordered build.
The authoring pipeline
- Describe. You state the intent in plain language and choose the target project.
- Enrich and ground. The fleet fetches the real schema of the entities in play, re-grounds the request on their actual fields and option-sets, and converts anything that cannot be grounded, a fabricated entity, attribute, or option-set, into a question rather than an assumption.
- Approve. You confirm the enriched "what will run" before anything executes. The plan is yours to approve.
- Plan. When the brief spans several artifacts, the orchestrator decomposes it into a dependency graph and orders it, leaves first.
- Generate, validate, repair. For each artifact, a type-specialist generator produces the FoL metadata, the verifiers check it, and any defect is repaired, looping until it passes.
- Reuse, then create. Before creating anything, the reuse judge checks whether an existing artifact already does the job. Otherwise the artifact is created live, on your approval, and dependents wire to it.
The authoring fleet
| Role | What it does |
|---|---|
| Enricher | Turns an ambiguous prompt into a precise, grounded brief. Fetches the real schema of the entities in play, re-grounds on their actual fields and option-sets, and turns anything ungroundable into a question rather than an assertion. You approve the enriched brief before anything runs. |
| Planner & orchestrator | Decomposes a multi-artifact brief into a dependency graph, orders it, and builds leaves first, so a flow that invokes a block finds that block already present. It primes each generator with the real signatures of the artifacts it will call, detects cycles, and keeps the graph consistent when a dependency is rebuilt. |
| Artifact-type generators | One generator per artifact family, each carrying the grammar and the real-world patterns for its type, producing the metadata in the shape that type requires: a formula's expression, a decision table's rows, a flow's action tree, an event's payload. |
| Grounding engine | The anti-fabrication core. Resolves every reference in the generated metadata against the project's live Dataverse metadata, entities, attributes, global and local option-sets, and invoked artifacts with their real project and input/output signature, and rewrites the metadata to the real names. It is deterministic: link, never fabricate. |
| Symbolic verifiers | Check the metadata against the grammar and a set of cross-reference invariants the grammar cannot express, output targets, decision-row column counts, construct arity, construct context. Each is calibrated to hold across the platform's real artifacts, so it flags genuine defects without false positives. |
| Reuse judge | Before creating anything, confirms whether an existing artifact already does the job by its behaviour, its real inputs, outputs, and logic, not merely its name, so the project reuses instead of duplicating. |
| Create-and-update engine | Creates the artifact live. For edits, it fetches the current metadata, applies the change, shows a before/after diff, and writes only on approval, and only when the edit is valid and fully grounded. |
The generate → validate → repair loop
No artifact is written the moment the model produces it. Each candidate runs through the loop first:
The verifiers catch what a grammar check alone cannot: an output that targets nothing, a decision row with the wrong number of columns, a construct used in a context where it is not allowed, an invocation whose arguments do not match the callee's real signature. A failing artifact is repaired, not discarded, the loop fixes the specific defect and re-checks, so the output converges on something correct instead of being thrown away.
The plan → reuse → build orchestrator
A brief that spans several artifacts is not generated as a flat list. The orchestrator:
- Plans a dependency graph from the brief and orders it so leaves are built first, a flow that calls a block is built after that block exists.
- Primes each generator with the real input/output signatures of the artifacts it will call, so every invocation targets a real artifact from the start.
- Reuses where an equivalent artifact already exists, wiring dependents to the real existing one instead of creating a duplicate.
- Builds in order, keeping the graph consistent, if a dependency is rebuilt, its dependents are kept aligned, and detecting cycles rather than looping forever.
This is why a single brief can yield a whole working suite, blocks, the flows that use them, the recipe that triggers a flow, the process that orchestrates them, and every reference resolves because the thing it points at was built, or found, first.
Human-in-the-loop
Logic Authoring writes to your project, so approval is built into the loop, not bolted on. You approve the enriched plan before generation runs, and you approve every create and every update before it is written. Edits are never silent: an update fetches the current metadata, applies the change, and shows a before/after diff you confirm. Name collisions are handled safely, an artifact is reused or renamed, never silently overwritten.