Agent Designer in Business Central: Build Custom AI Agents Without Writing Code

For two years, “AI in Business Central” meant one of two things: the built-in Copilot features Microsoft shipped (which you could use but not change), or AL development work that required a developer, a DevOps pipeline, and weeks of lead time.

Business Central 2026 Release Wave 1 changed that. Agent Designer — generally available since May 2026 — lets a consultant, a product owner, or a domain expert in finance or operations build a custom AI agent using natural-language instructions. No AL code. No extension to compile. No waiting on a development cycle.

The agents you build run on the same runtime as Microsoft’s built-in Payables and Sales Order agents, inherit BC’s standard permission model, and can be prototyped in a sandbox before going anywhere near production.

This article explains what Agent Designer actually is, what it’s genuinely good at, what it can’t do yet, and what it costs to run. No hype. Just the real picture.

What Agent Designer Is (And Isn’t)

Let’s get the framing right, because a lot of the early coverage oversold it.

It Is: A Low-Risk Way to Prototype Custom Agents

Agent Designer is the “envision and prototype” layer of Microsoft’s AI Development Toolkit for Business Central. It gives you:

• A simple in-product editor to define, refine, and test agent instructions
• Natural-language authoring — describe what the agent should do in plain words
• The ability to point the agent at live BC data and specific capabilities
• Testing against real UI and data in a sandbox environment
• Import/export of agent definitions as JSON (for backing up or moving agents across sandboxes)
• The same agent runtime used by the built-in Payables, Sales Order, and Expense agents

It Is Not: A Magic No-Code Wand

Three honest caveats:

1. It’s mostly for prototyping the design. The low-risk environment is for validating ideas and building confidence before committing to full implementation. When you’re ready to productize — with email triggers, scheduled runs, or deep integration — a developer takes over using the AI Development Toolkit APIs.

2. There’s no built-in auto-triggering yet. Microsoft’s own docs are explicit: in public preview, you trigger a custom agent by manually creating a task for it. You can simulate incoming emails by pasting the header and body into the task message, but there are no built-in integrations to automatically trigger agents from incoming emails, events, or schedules. That’s what AL developers do with the toolkit’s APIs.

3. It’s online-only. Like all BC Copilot and agent features, Agent Designer requires Business Central online (SaaS). On-premises and partner-hosted deployments don’t have access.

The Timeline: From Preview to Production

Agent Designer moved fast in 2026.

The sandbox-to-production path was the critical unlock. Before 28.1, Agent Designer was a prototyping tool — useful for demos, not for real work. After 28.1, custom agents can run in production alongside the built-in Payables and Sales Order agents.

Who It’s For

Microsoft’s positioning is deliberate: this is for people who are not full-stack AL developers.

• Consultants and product owners — prototype a client-specific workflow, validate it with the client, then hand the validated design to a developer.
• Domain experts in finance or operations — automate a repetitive process they understand deeply but can’t code.
• Power users — test an idea before spending budget on AL implementation.
• Developers — use it as a fast prototyping surface before writing production-grade AL.

The pattern we see with clients: a finance controller describes an agent in plain English (“when a vendor invoice arrives for a PO that’s already fully received, flag it for review and attach the PO match result”), tests it in the sandbox against real data, and only then do we invest in the AL work to make it production-grade with email triggering and exception handling.

What You Can Build

The ceiling is defined by BC’s permission model, not the tool. If a human user with a given permission set can do it, an agent with that permission set can be instructed to do it.

Realistic, high-value examples:

• Invoice review triage — flag vendor invoices that fail PO matching, route them for human review
• Customer order intake — read order emails, draft sales quotes, check stock (this is what the built-in Sales Order Agent does; custom agents extend it to your specific rules)
• Reconciliation helpers — compare bank lines against open entries and surface exceptions
• Data quality monitors — scan item or customer master data for gaps (missing GLN, missing VAT IDs) and produce a fix list
• Approval routing — apply your company’s specific approval thresholds to documents

The common thread: these are processes that are rules-heavy but judgment-light. The agent does the repetitive 80% and flags the 20% that needs a human.

Permissions & Security (The Part That Matters)

This is where a lot of “AI in ERP” fear lives, and it’s worth being precise.

A custom agent built in Agent Designer inherits the permissions of the user account it runs under. It can access exactly the data and capabilities that account is permitted to access — no more, no less.

• Every action is logged.
• Permissions are enforced by BC’s standard model.
• A custom agent does not get any access a human user with the same permissions wouldn’t have.

This is the same security and permission model the built-in agents use. The agent is, effectively, a very fast, very literal user who works inside the guardrails you set.

The practical implication: before you design an agent, decide which user profile it runs under, and keep that profile minimal. If an agent only needs to read invoices and create draft documents, don’t give it a profile that can also post journals.

Cost: Copilot Credits, Not Licenses

Custom agents — like the built-in Payables, Sales Order, and Expense agents — consume Copilot credits, not flat per-user or per-transaction licenses.

• Credits can be provisioned through prepaid or pay-as-you-go models.
• The agent consumes credits as it performs its steps.
• This gives flexible cost management as your AI usage scales.

There’s no additional Business Central license cost for Agent Designer itself — it’s included in your online subscription. What you pay for is the AI consumption (credits) plus, if you productize, the AL development time.

The honest caveat on cost: because triggering is currently manual (no auto-trigger yet), the credit burn in pure-prototype mode is modest. The moment a developer wires up automatic triggers and the agent starts processing a real inbound stream, that’s when you need to actually plan credit budgeting — and track it, because “set and forget” is how AI spend surprises people.

What It Can’t Do (Yet)

Be clear-eyed about the gaps, because they define where you still need a developer.

1. No automatic triggering. Manual task creation only, in the current design. Email/event/schedule triggers require AL via the AI Development Toolkit APIs.
2. Online-only. No on-premises or partner-hosted deployment.
3. Prototype-first philosophy. The designed agent is a validated concept; production-grade deployment still means AL implementation for anything beyond the simplest use case.
4. Unbound actions gap in integrations. (Related, worth noting: if your custom agent needs to trigger AL actions that can only be called over OData, you’ll hit the broader OData/SOAP deprecation issue — see our SOAP/OData migration guide.)

None of these are dealbreakers. They just mean Agent Designer is the start of the journey, not the end.

The Practical Path: Prototype → Validate → Productize

Here’s the workflow we recommend, and it mirrors Microsoft’s own intended flow.

Phase 1 — Prototype in the Sandbox (Days, not weeks)

• Identify one repetitive, rules-heavy process worth automating.
• Define the agent in the in-product editor using natural language.
• Point it at the BC data it needs, with a minimal permission profile.
• Test against live UI and data in the sandbox.
• Iterate on the instructions until the agent behaves.

Your role: describe the process you want automated. What we handle: setup, permission scoping, and guiding the iteration.

Phase 2 — Validate the Concept (Days 1–2)

• Run the agent against realistic scenarios, including edge cases.
• Show it to the stakeholders who’ll actually use the output.
• Export the agent definition (JSON) as the validated specification.

Deliverable: a proven agent design plus a JSON definition you can hand to any developer.

Phase 3 — Productize with AL (Weeks)

• A developer takes the validated design and implements it in AL using the AI Development Toolkit.
• Add the missing pieces: email triggers, scheduled runs, exception handling, integrations.
• Deploy the extension to production.

Deliverable: a production agent that runs automatically, on your specific rules, with proper monitoring.

The key insight: you didn’t waste budget on a developer to discover whether the idea even works. That discovery — the expensive, uncertain part — now happens cheaply in the sandbox.

What This Costs (Honest Numbers)

Compare this to the old way: a custom agent-like automation meant a developer scoping, building, and guessing what the business wanted, often discovering midway that the requirements were wrong. The prototyping layer collapses the riskiest part of the cost curve.

The honest note: not every business needs custom agents. If the built-in Payables Agent or Sales Order Agent covers your process, don’t build a custom one. Agent Designer earns its keep when your process is specific enough that the out-of-the-box agents don’t fit.

Team & Roles

The process owner is the linchpin. An agent designed by someone who doesn’t live the process will automate the wrong thing. The domain expert doesn’t need technical skills — they need to be in the room.

What Nobody Tells You

1. The hard part isn’t the tool, it’s the permission profile. Most agent failures we see aren’t the AI misbehaving — it’s the agent running under a profile that’s either too broad (scary) or too narrow (the agent can’t do what you asked). Spend real time on permission scoping.

2. “No code” still needs a developer at the end. Agent Designer removes the prototyping cost, not the production cost. Anything that runs unattended needs AL for triggers and monitoring. Budget for it.

3. Copilot credits are the hidden variable. The design feels free because the tool is included. The moment the agent runs automatically at scale, credit consumption becomes a line item. Track it from day one, or the first month-end reconciliation will surprise you.

Checklist

• Confirm you’re on Business Central online (SaaS) — Agent Designer is online-only
• Pick one repetitive, rules-heavy process worth automating
• Name a process owner who lives that workflow
• Define a minimal permission profile for the agent to run under
• Build the agent in the in-product editor using natural language
• Test against live UI and data in the sandbox
• Iterate on instructions until the agent behaves consistently
• Validate with the stakeholders who’ll use the output
• Export the agent definition (JSON) as the validated spec
• Decide: productize with AL, or stop (the built-in agent may suffice)
• If productizing: add email/event triggers, monitoring, exception handling via AL
• Set up Copilot credit tracking before going to production

FAQ

Do I need to write AL code to use Agent Designer?

No. Agent Designer is specifically designed so consultants, product owners, domain experts, and power users can build custom agents using natural-language instructions — no AL code required. You will need AL development if you want to productize the agent with automatic triggers, scheduled runs, or deep integrations, but the initial design and prototyping is code-free.

Is Agent Designer generally available or still in preview?

Generally available since May 2026. It opened in public preview on February 6, 2026 (sandbox only), then reached GA with production support. Update 28.1 (May–June 2026) added the ability to deploy custom agents to production environments plus an evaluation tool.

Does a custom agent get full access to my Business Central data?

No. A custom agent inherits the permissions of the user account it runs under — no more, no less. Every action is logged and permissions are enforced by BC’s standard model. The agent effectively operates as a fast, literal user inside the guardrails you set.

Can I trigger a custom agent automatically from incoming emails?

Not yet, without development. In the current design, you trigger a custom agent by manually creating a task for it (you can paste an email header/body into the task message to simulate an incoming email). Automatic triggering from emails, events, or schedules requires a developer using the AI Development Toolkit’s APIs.

What does it cost to run custom agents?

Agent Designer itself is included in your Business Central online subscription — no additional license. The agents consume Copilot credits as they perform steps, provisioned via prepaid or pay-as-you-go. Productizing a validated agent (AL implementation, triggers, testing) typically runs €5,000–€20,000 depending on complexity.

Is Agent Designer available on Business Central on-premises?

No. Like all Copilot and agent features, Agent Designer is available only to Business Central online (SaaS) customers. On-premises and partner-hosted deployments don’t have access to agent capabilities.

How does Agent Designer compare to the built-in Payables and Sales Order agents?

The built-in agents (Payables, Sales Order, Expense) are pre-built for specific processes and work out of the box. Agent Designer is for building custom agents for processes those don’t cover — it extends the same runtime and permission model. If a built-in agent fits your process, use it; build custom only when your workflow is specific enough that the defaults don’t fit.

Want to prototype a custom agent for a specific process in your Business Central? Book a scoping call → We’ll help you design it in the sandbox, validate it against your real data, and productize it when you’re ready. Or explore our custom development services for the AL work that turns a validated agent into production automation.