I Built My First Finance Agent in a Couple of Weeks

The first article in my Finance Agent series

Over the last couple of weeks, I've been experimenting with Microsoft Copilot Studio, Dynamics 365 ERP MCP, and Power Automate to see what was really possible inside Dynamics 365 Finance.

What started as a demo scenario quickly turned into something much more interesting.

The original goal was simple. I wanted to help credit and collections teams respond to credit holds more efficiently. As I continued building and testing, I started discovering that agents could fundamentally change how people interact with ERP systems.

And honestly, I don't think we're anywhere close to seeing the full potential yet.

Quick Video 

The Problem I Wanted to Solve

If you've spent time working with Credit & Collections in Dynamics 365 Finance, you've probably seen this scenario before.

A sales order gets placed on credit hold.

The sales team starts asking questions.

The credit team may not even know the hold exists until someone contacts them.

Then the investigation begins.

The credit analyst starts navigating through screens looking for:

• Open invoices
• Aging information
• Credit limits
• Payment history
• Collection activities
• Disputes
• Promises to pay
• Open sales orders
• Credit review information

The data is there.

The challenge is that it's spread across multiple places.

I found myself asking a simple question:

Why am I spending more time finding information than analyzing it?

That question became the foundation for everything that followed.

Building the First Collection Manager Agent

The first agent I built was a Collection Manager Agent.

The idea was straightforward.

I wanted an agent that could gather all the credit and collections information I typically review and present it in a single conversation.

Instead of jumping between screens, I could ask the agent to analyze a customer and receive a consolidated review of:

• Open invoices
• Aging
• Payment history
• Collection activities
• Disputes
• Promises to pay
• Credit exposure
• Open orders

What surprised me wasn't that the agent could retrieve the information.

What surprised me was how quickly users understood the value.

When I demonstrated it, the most common reaction was:

Can I use it today?

The second most common reaction was:

There should be agents like this for every role.

That was the moment I started realizing this wasn't just a cool demo.

This could fundamentally change how people work inside ERP systems.

The Key Enabler: Dynamics 365 ERP MCP

As I started building, I quickly realized that Dynamics 365 ERP MCP was the key enabler behind the entire solution.

Without MCP, I probably wouldn't have attempted this project.

The ability to securely work with Dynamics 365 Finance data through agents dramatically changes what's possible.

Suddenly, I wasn't building disconnected AI experiences.

I was building agents that could understand and work with actual business data.

Once that clicked, my thinking changed.

Instead of asking:

What can I automate?

I started asking:

What business role could benefit from its own agent?

That's a much more interesting conversation.

Learning Copilot Studio

I came into this project with much more Power Automate experience than Copilot Studio experience.

I understood automation.

I understood business processes.

But building agents is different.

The biggest challenge wasn't finding Finance data.

The biggest challenge was learning:

• How prompts influence behavior
• How instructions affect responses
• How agents and flows work together
• How to structure outputs for different audiences

I probably rewrote prompts more times than I can count.

Every time I thought I had something working well, I would think of another feature.

Or another use case.

Or another idea.

Then I would add it.

Then add another one.

Then another.

Sound familiar?

My Biggest Mistake

Looking back, my biggest mistake was not starting with a narrower scope.

I kept thinking of new capabilities.

I kept expanding the agent.

I kept adding prompts.

And the more I added, the harder it became to get the focused responses I wanted.

Eventually I realized something important:

One agent should not do everything.

It sounds obvious now.

It didn't feel obvious at the time.

My Biggest Breakthrough

The biggest breakthrough happened when I stopped trying to make one agent solve every problem.

Originally, the Collection Manager Agent was doing everything.

The more functionality I added, the more difficult it became to get consistent and focused responses.

That's when I started separating responsibilities.

Instead of one large agent, I created specialized agents for specific purposes.

That change immediately improved the user experience.

More importantly, it improved the results.

I learned that prompt engineering isn't just about writing better instructions.

It's also about creating clear boundaries and responsibilities.

The best agents aren't necessarily the biggest agents.

They're the agents that know exactly what job they're supposed to do.

The Feature Everyone Loved

Interestingly, the feature that generated the most excitement wasn't the Collection Manager Agent.

It was the automated credit hold alert.

When a credit hold occurs, an alert appears in Microsoft Teams with the key information needed to begin investigating the issue.

The credit team no longer has to wait for a salesperson to reach out.

The information comes to them.

The reaction was immediate.

People understood the value in seconds.

Instead of navigating through multiple screens just to get started, users had immediate access to relevant information and a recommended next step.

If they needed more information, they could dig deeper.

If they wanted to contact the customer, they could continue that process.

If they needed to prepare for a collection call, they had a starting point.

The alert wasn't replacing the analyst.

It was eliminating the busy work.

What I Learned About User Experience

One of the biggest lessons from this project had nothing to do with technology.

It had everything to do with user experience.

The most successful parts of the solution weren't necessarily the most technically impressive.

They were the parts that reduced friction.

The parts that reduced navigation.

The parts that brought information together.

The parts that explained recommendations.

Users don't wake up in the morning excited to navigate ERP screens.

They want answers.

They want guidance.

They want information presented in a way that helps them make decisions.

That's where agents can have the biggest impact.

Why Journal Entry Processing Became My Next Project

After I started receiving feedback about the Collection Manager Agent, people kept saying:

There should be agents like this for every role.

I agreed.

The next role that immediately came to mind was Journal Entry Processing.

I've worked with many Dynamics 365 Finance customers over the years, and one thing I've noticed is that a lot of users still prefer Excel.

Many don't like the Dynamics 365 Excel Add-in.

Many don't want to use Data Management to upload journal entries.

That got me thinking.

What if a user could upload an Excel file and have an agent guide them through the validation, workflow, and approval process?

Not create journals automatically.

Not post journals automatically.

Not bypass controls.

Instead, the agent would help validate entries, simplify approvals, and guide the user through the process while keeping humans in control.

To me, that's where AI becomes truly valuable.

Not replacing people.

Helping people work more efficiently.

My Advice If You're Thinking About Building a Finance Agent

If there's one thing I've learned during the last couple of weeks, it's this:

There is far more possible than most people realize.

Focus on the user experience first

Don't start with technology.

Start with the user.

What information are they looking for?

What decision are they trying to make?

What work are they doing repeatedly?

Start smaller than you think

Pick a focused use case.

Solve one problem well.

You can always expand later.

Test constantly

Small prompt changes can dramatically change results.

The more testing you do, the better your agent becomes.

Use AI to help build AI

I used tools like Copilot and Claude throughout the process to help generate ideas, refine prompts, challenge assumptions, and build test scenarios.

Don't be afraid to use them.

They're incredibly useful development partners.

Final Thoughts

Two weeks ago, I wanted to build a better way to investigate credit holds.

Today, I'm thinking about what role should get an agent next.

That's a pretty remarkable shift.

The technology is moving quickly.

The tools keep getting better.

And for the first time, it feels like we're moving beyond simply automating processes and toward creating truly role-based experiences inside ERP systems.

The question isn't whether finance agents are possible.

I've already seen that they are.

The real question is:

Which finance role should get an agent next?

In my next article, I'll walk through how I built the Collection Manager Agent, what worked, what didn't, and the lessons I learned along the way.