By Aisling Dynamics Business Solutions | July 2026
Microsoft has opened the door to something Dynamics 365 Business Central users have wanted since Copilot arrived: the ability to design, test, and eventually ship your own AI agents — digital coworkers that read tasks, navigate Business Central screens, follow your business rules, and ask a human before doing anything consequential.
The vehicle is the Business Central AI development toolkit, which pairs a no-code agent design experience (for prototyping in a sandbox) with a full AL coding framework (for turning proven prototypes into production-ready extensions). Here’s everything you need to know — including the release timeline and our consultants’ tips and tricks for each part of the journey.
Release Timeline: When Can You Use It?
The custom agent capability has moved fast:
- June 2025 (BCTechDays): Announced as the “Agent Builder Playground” in private preview for selected partners (Kauffmann).
- November 2025 (Directions EMEA): Demonstrated publicly again.
- February 6, 2026: Public preview — renamed “Envision and design AI agents in Business Central,” available in sandbox environments (version 27.2 or later; it shipped broadly with 27.4) (Azurecurve).
- May 2026: General availability target in Microsoft’s 2026 Release Wave 1 plan for the design experience.
- Today: The AI development toolkit itself is still labeled preview in Microsoft’s documentation — the design experience is sandbox-only, and the production path is a developer-built AL extension.
Aisling Tip: Treat “preview” as an invitation, not a warning. The design experience is deliberately sandboxed so you can experiment with real (copied) data at zero risk. Companies that prototype now will have validated use cases ready the moment the production tooling matures.
What Exactly Is a Custom Agent?
Business Central already ships prebuilt agents — the Sales Order Agent turns customer emails into sales orders, and the Payables Agent processes vendor invoices. Custom agents extend that same runtime to your processes.
According to Microsoft’s overview, an agent:
- Interacts with the Business Central user interface and data — it navigates pages, sets fields, and invokes actions like a (very fast) user.
- Runs with explicit permissions and its own profile (role), so it sees only what you allow.
- Logs every step in a timeline view, keeping a human in the loop for review and consent.
- Is guided by natural-language instructions — not code.
The toolkit is aimed at four audiences: product owners prototyping AI features, domain experts evaluating possibilities, consultants exploring automation scenarios, and developers validating use cases before building AL extensions.
- Pick a “checker,” not a “doer,” for your first agent. Validation scenarios (reviewing sales orders for missing data, flagging unusual invoices) are lower-risk than creation scenarios, and Microsoft’s own tutorial builds a Sales Validation Agent for exactly this reason.
- If a task is repetitive, rule-based, and screen-driven, it’s a candidate. If it requires judgment calls or data outside Business Central, keep a human on it — or scope the agent to just the mechanical part.
The Agent Lifecycle: Six Phases
Microsoft defines a clear lifecycle: Create → Configure → Activate → Iterate → Graduate → Clean up.
- Create — set up the agent’s identity and profile.
- Configure — write instructions and assign permissions.
- Activate — enable the agent and add tasks (tasks can only be added while the agent is active).
- Iterate — test, refine instructions, adjust permissions.
- Graduate — export your learnings into a production AL extension.
- Clean up — deactivate and remove the prototype.
Prerequisites before you start: enable the Custom Agent capability in Copilot & agent capabilities, get the AGENT – ADMIN permission set (add AGENT – DIAGNOSTICS for troubleshooting data), a sandbox on version 27.2+, and billing setup for agent capabilities in your tenant.
- Use a sandbox copy of production data. Microsoft explicitly allows customer data in sandboxes — realistic data exposes instruction gaps that demo data never will.
- Don’t skip the billing setup. Agent runs consume paid AI capacity (Copilot credits). Set up consumption billing before activation, and review the agent’s credit consumption during iteration so costs never surprise you.
- Budget for iteration. Nobody writes perfect instructions on the first try. Plan several test-refine cycles; most fixes are instruction edits, not technical changes.
Writing Instructions: Train It Like a New Hire
Instructions are natural-language descriptions of the agent’s purpose, rules, and boundaries — effectively a detailed prompt. Tech Sphere Dynamics frames it perfectly: “You’re not coding an extension — you’re onboarding a new employee.”
- Structure instructions in three blocks: RESPONSIBILITY (who the agent is and its mission), GUIDELINES (rules and boundaries), and INSTRUCTIONS (step-by-step procedure).
- Use Microsoft’s instruction keywords. The runtime recognizes special keywords such as Memorize, Reply, Write an email, Request a review, Ask for assistance, Set field, Use lookup, and Invoke action. Using them makes agent behavior far more predictable.
- Give MEMORIZE an example format. Agents don’t store the full state of every page they visit. When you tell an agent to memorize data, include an example of the exact format — accuracy improves significantly.
- Write in English for now. The preview officially supports English only; other languages may work but aren’t guaranteed.
- Escalate deliberately. Build “ask for assistance” rules into the instructions for edge cases, so the agent hands off to a human instead of guessing.
Permissions and Profiles: Least Privilege Wins
Every agent operates within two boundaries: a permission set (what data and actions it can access) and a profile (which UI elements it can see).
- Create a custom profile just for the agent. Microsoft strongly recommends it. Use page customization to hide actions, views, and layouts the agent doesn’t need — less visual noise means higher accuracy.
- Start from zero, add back what’s needed. Developers can use page customization properties like ClearActions, ClearLayout, and ClearViews set to true, plus InsertAllowed/DeleteAllowed set to false, then explicitly restore only the controls the agent requires.
- Remember: a hidden field is an invisible field. If the E-Mail field isn’t visible in the agent’s profile, the agent cannot search by email — no matter how good the instructions are. When an agent “can’t find” something, check the profile before rewriting instructions.
- Permissions are an intersection. An agent can never exceed the permissions of the user who created the task. And if a different user answers a review request, the task continues with that user’s permissions — plan your approval routing accordingly.
Tasks, Triggers, and Attachments
Tasks are how agents receive work. In the designer you trigger tasks manually (including with attachments) to simulate real scenarios. In code, the Tasks AL API connects agents to real business events.
- Simulate before you automate. In the sandbox, manually feed the agent the same emails, attachments, and requests it would receive in real life, and watch the timeline step by step.
- Developers: use the fluent task pattern. Agent Task Builder and Agent Task Message Builder (Initialize → SetExternalId → AddTaskMessage → Create) let event subscribers — a new record, an incoming email — create agent tasks automatically.
- Know the attachment limits. The runtime extracts text from attachments for context; it isn’t computer vision or full OCR. For low-quality scans or complex forms, pre-process with a document intelligence service and pass the extracted data instead.
- Mind the UI limits. Agents can interact with only one list per page, and they can’t use Tell Me to search — they navigate only through the actions and links their profile exposes.
From Prototype to Production: Graduating to AL
The design experience is sandbox-only — you cannot deploy a designed agent to production directly. The path, documented by Kauffmann, is:
- Export the agent from the designer — you get an XML file with the full design.
- In VS Code, run AL: New Project and choose the Agent template.
- Follow the README to apply your exported configuration (AI coding assistants can do most of this conversion for you).
- Implement the trigger logic — the AL interfaces (IAgentFactory, IAgentMetadata, IAgentTaskExecution) plus the Tasks AL API wire the agent into real business events.
- Compile, install, and test — a converted agent app can be running in a sandbox in as little as 15 minutes.
- The XML export is a blueprint, not an app. There’s no one-click import that produces a finished agent — the conversion to AL is a real (if fast) development step. Budget for it.
- Keep instructions updatable. Store instruction text as a resource in the extension and refresh it on install/upgrade, so tuning agent behavior doesn’t require code changes.
- Add telemetry from day one. Structured telemetry and agent annotations let you audit every decision in production and diagnose issues quickly — auditors and your future self will thank you.
- Sandbox only for the design experience — never production.
- Preview status: features and behavior can change without notice.
- English only (officially) during preview.
- Agents inherit their creator’s ceiling — they can’t have more permissions than the user who made them.
- One list per page, and no Tell Me navigation.
- Not compliance tooling: Microsoft says don’t use the toolkit for compliance or security evaluation, and use production-ready Copilot features for end-user training.
The AI development toolkit is Microsoft’s clearest signal yet that agents are the future of ERP work: prototyped by the people who know the process, hardened by developers, and governed by permissions, profiles, and human review. The design experience previewed February 6, 2026, hit its GA milestone in Microsoft’s Wave 1 plan in May 2026, and the graduate-to-AL path makes production a realistic next step rather than a leap of faith.
Ready to build your first agent? Aisling Dynamics Business Solutions has guided companies through every Dynamics wave since 2009. We’ll help you pick a pilot use case, stand up a sandbox, write instructions that work, and graduate your prototype to production. Contact us at (800) 977-9018 or info@aislingdynamics.com.
- Designing and coding agents (preview) — Microsoft Learn
- Designing and coding agents landing page — Microsoft Learn
- Dynamics 365 Business Central 2026 Release Wave 1 Plan — Microsoft Learn
- Designing Agents for Business Central — Arend-Jan Kauffmann
- A practical guide to creating agents in Business Central — Tech Sphere Dynamics
- Envision and design AI agents in Business Central — Azurecurve
- About Aisling Dynamics | Microsoft Partner
- What We Offer | Microsoft ERP | Aisling Dynamics
Contact Aisling Dynamics | Microsoft Dynamics Business Applications