Building Copilot Features Inside Business Central

There's a lot of Copilot demo content out there that looks impressive and falls apart the moment it meets a real permission model or real data volume. Building Copilot features that actually ship in a production BC environment requires a different discipline than building a flashy prototype.

Start from the permission model, not the prompt

The first design question for any Copilot feature isn't "what should the AI say" — it's "what is this user actually allowed to see and do, and how do we guarantee the AI respects that." In Business Central, that means:

• Any data the AI reads should go through the same security filtering a normal user session would get — not a service account with broader access "for convenience."
• Any action the AI triggers should run under the calling user's permission set, so an AI action can never do something the human user couldn't do themselves.
• Sensitive fields (cost prices, margins, personal data) need explicit consideration — should the AI feature even have access to them for this user role?

Get this wrong and you don't have a Copilot feature, you have a permission bypass with a chat interface.

A worked example: natural-language reconciliation

One of our own tools — a reconciliation extension — is Copilot-enabled. A user can type something like "Reconcile statement V-SN/0000014" and the system will:

1. Parse the statement reference from natural language
2. Look up the statement, scoped to what that user is permitted to see
3. Run the matching logic against posted entries — same logic the manual "Reconcile" button uses, not a separate AI-only path
4. Return a structured result: matched, partial, and unmatched lines, with the difference clearly shown

Notice what's not AI here: the actual matching algorithm is deterministic, tested, auditable code. The AI's job is narrow — turning a natural language request into a structured action, and turning structured results back into a readable summary. This is the pattern we come back to again and again: use the LLM for the fuzzy edges (understanding intent, summarising output), and keep the business logic itself deterministic.

Why "AI does everything" fails in ERP contexts

Business Central holds financial and operational data where a wrong answer has real consequences. An LLM that directly computes a discount, decides whether to post a transaction, or free-generates a G/L entry is a liability, not a feature. The reliable pattern is:

• LLM for interpretation: turning "show me overdue invoices for customers in Maharashtra over 30 days" into a filtered query.
• Deterministic code for execution: the actual query, the actual posting, the actual calculation.
• LLM for summarisation: turning a result set back into a natural sentence a busy person can scan quickly.

The AI wraps the experience; it doesn't replace the business logic underneath.

Agents versus Copilot features — know which you're building

"Copilot feature" and "agent" get used interchangeably, but they're different in an important way:

• A Copilot feature is invoked by a user, in the moment, with a human present to review the result before anything commits.
• An agent runs autonomously — on a schedule, or triggered by an event — and takes actions without a human in the loop for each individual decision.

Agents need a stricter design: explicit scope boundaries, an audit trail for every action taken, and clear escalation points where the agent stops and asks a human rather than guessing. We built an agent that reads inbound development requests over email, generates AL code, and packages a solution for review — it never auto-deploys anything. The human checkpoint is deliberate, not a limitation we're working around.

Practical starting points

If you're planning your first Copilot feature in BC, we'd suggest starting narrow:

• Pick one well-understood, already-deterministic workflow (reconciliation, a specific report, a specific approval step)
• Wrap natural language input/output around the existing logic — don't rewrite the logic in the AI layer
• Test with the same permission sets your actual users have, not an admin account
• Measure adoption, not just demo reactions — a feature people actually use weekly beats an impressive one-off demo

Copilot in BC is genuinely useful when it removes friction from something people already do. It's a liability when it becomes a second, unaudited way to change data.