u/oartconsult

Most Copilot Studio agents only use Microsoft tools — query Excel, read SharePoint, send an email. The moment you need to call an external third-party system via HTTP, most setups fall apart fast.

So I built a logistics assistant that shows exactly how to do it — including the messiest part: the user never gives you all the data upfront.

Here's what it actually does:

• Takes an incomplete request — "get me a delivery price from Chicago to New York" — and figures out what's missing before making any API call
• Runs a decision loop driven by a single prompt action that decides the next step every iteration: ask the user, search the web, call the API, answer, or stop
• Searches the web automatically for missing details — if the user says "it's just a shoebox," the agent finds the dimensions itself instead of asking
• Builds a structured JSON payload and sends it via HTTP request to an external shipping API with proper auth headers
• Returns real carrier options with prices and delivery times

The architecture is one topic acting as a controller, one prompt making every routing decision, one variable accumulating everything — original request, follow-up answers, web results — so the agent gets smarter with every loop.

The main point of this build is the HTTP pattern: once you can call one external API this way, you can call any of them. The logistics use case is the demo — the same architecture applies to any third-party system your business connects to.

Three live demos in the video showing the full loop from vague input to real API response.

The full flow is in my flospect library — same link as always, this build has been added. Every node, prompt, variable, and HTTP setup. Ready to view and rebuild in your own environment.

Video walkthrough + library link in the comments.

What external APIs or third-party systems have you needed to connect to from Copilot Studio? Curious what others are trying to integrate.

Every time I finish a Copilot Studio build, I hit the same uncomfortable moment: how do I properly validate this works across all the scenarios it's going to face in production?

The happy path is easy. But edge cases, ambiguous inputs, error handling, boundary conditions — those are the things that break at the worst possible moment.

Most approaches I've seen fall into one of three buckets:

• A spreadsheet with test cases that nobody keeps updated
• Clicking around in the test chat and hoping for the best
• No structured testing at all — just shipping and monitoring what breaks

None of those feel right for anything running in a real environment.

Curious what others are doing — do you have a systematic approach to testing before go-live, or is it still mostly informal?

I've been building Copilot Studio flows for clients for a while, and one thing keeps coming up: once a flow is built, handing it over cleanly is harder than building it.

There's no native way to share a complete picture of an agent with a client or internal team — what topics are inside, how the logic is structured, what flows are connected — without giving them access to your environment or spending hours writing it up manually. And inside organisations, cataloguing what's been built across projects and teams has the same problem.

I built two videos about this earlier, video links in the comments.

So I built a Copilot Studio solution zip importer for flospect. Here's what it would do:

You export your agent from Microsoft 365 as a zip and drop it into flospect. It reads the contents — topics, agent flows, Power Automate flows — and lets you select what to import. AI then generates a visual canvas from the structure: nodes grouped, logic labelled, everything readable. You can configure the audience, layout direction, and verbosity level before generating. From there you can share it with clients or stakeholders, build test protocols, and generate documentation — all without exposing your environment or credentials.

The feature is technically ready. But before I release it, I genuinely want to know: would you use a zip importer like this? What would you use it for — client handover, internal cataloguing, something else? And is there anything you'd want it to do that isn't described above?

Most invoice processing setups I've seen rely on someone opening each email, reading the attachment, and typing the data manually into a system. At volume that becomes a part-time job.

So I built a flow that handles all of it automatically — from the moment an email lands in a dedicated folder to the moment the structured data is extracted and registered.

Here's what it actually does:

• Triggers when a new email arrives in a "To Process" folder — only processes emails with attachments, ignores everything else
• Loops through all attachments in a single email — one email can contain multiple invoices
• Saves each attachment to SharePoint, runs OCR text recognition, and stores the output as a structured text file including bounding box coordinates so the AI understands where data sits on the page
• Passes only the file path to the Copilot Studio agent — not the full OCR text — to avoid overloading the prompt
• AI extracts the fields: invoice number, vendor, customer, invoice date, due date, amount, currency
• Validates completeness — if any required field is missing, the attachment routes to an error folder instead of passing silently
• Registers the extracted data to a data table — in my example an online Excel file, but the same logic applies to any structured data target you connect to
• Moves the original email to a processed folder when done

Five attachments in the live demo: one PNG, one JPEG, a 2-page PDF, a 5-page PDF, and one file with a missing field on purpose to show the error routing. Four clean rows registered, one file in the error folder.

One licence note: the "Recognize text in image or document" action in Power Automate requires a Power Automate Premium licence. Worth checking before you build.

The full flow is in my flospect library — same link as always, this build has been added. Every node, prompt, variable, and formula. Ready to view and rebuild in your own environment.

Video walkthrough + library link in the comments.

What's the most repetitive document process your team is still handling manually? Curious what others are dealing with.

One thing I've learned delivering Copilot Studio agents: if the underlying SharePoint folder structure is inconsistent, the agent inherits the problem. Files in the wrong folder, subfolders under the wrong parent, naming that doesn't follow any convention — it causes misrouting, wrong data retrieval, and hard-to-debug failures.

The root cause is simple: colleagues move fast, nobody monitors the structure, and the mess compounds quietly over time.

So I built a Copilot Studio agent that checks the folder structure daily and sends a report. It's a straightforward build — one of the simpler ones I've done — but it solves a real operational problem.

Here's what it does:

• Recurrence trigger runs every morning at 8 AM automatically
• Get Files Properties tool pulls file and folder metadata from a SharePoint library
• AI prompt analyses the structure and detects misplaced files, wrong subfolder placement, and naming inconsistencies
• Generates a structured report with a prioritised to-do list — file path, issue type, created by, where it needs to move
• Flags items that need manual review where metadata alone isn't enough to decide
• Sends the full report by email before the working day starts

Full flow is in my flospect library — same link as always, this build has been added. Video walkthrough + library link in the comments.

What does your current folder governance look like — manual checks, nothing, or something automated?

Copilot Studio has a zip export, but it's essentially a deployment package. You can move it between environments, but you can't read it, present it, or hand it to someone who wasn't involved in building it.

Which means every time I need to show a client or a manager how an agent actually works — the logic, the decision branches, the prompts, the variables — I'm either recording a screen walkthrough, taking screenshots, or rebuilding the explanation from scratch in a separate document.

None of those scale.

Curious what others do here. If you could export a Copilot Studio agent into a genuinely useful format — not just a deployment package — what would that look like for you?

A visual flow diagram? A structured document with the prompt logic included? Something you could hand to a non-technical stakeholder and have them understand it? Or is this a problem most people just accept and work around?