AI Builder Credits Are Gone: How Your Document-Processing Flows Actually Behave

Scenario: AP team with invoice processing flows

Assume a fairly standard setup:

• Department: Accounts Payable
• Flow type: Cloud flows triggered when a new file arrives in SharePoint or OneDrive
• AI capability: Prebuilt Invoice processing or Document processing model (now surfaced as AI Builder actions under the AI models category)
• Actions in the flow:
  • AI Builder – Extract information from invoices (or custom document processing model)
  • Post-processing: Write results to Dataverse/SQL, send approval, update ERP

The flow has been running for months on seeded AI Builder credits that came with Power Apps/Power Automate licences. Those seeded credits end on November 1, 2026, and there is no automatic transition from AI Builder credits to Copilot Credits.

From November 2 onward, this AP team starts seeing:

• Runs marked as Failed for flows that call AI Builder
• Error messages referencing capacity, quota, or insufficient AI Builder credits
• Some flows not even starting if they’re using a managed environment with strict capacity checks

We’ll use this AP scenario to anchor the rest of the article.

What actually happens when AI Builder credits hit zero

When your AI Builder credits reach zero or you no longer have any AI Builder capacity assigned to the environment, document-processing flows do not degrade gracefully. Key behaviours:

1. AI Builder actions in flows start failing

For any cloud flow that uses AI Builder (including document processing models):

• The flow still triggers as usual (e.g. on new file in SharePoint).
• The AI Builder action (e.g. Predict, Extract information from invoices, Recognize text in an image) will:
  • Return an error indicating insufficient AI Builder capacity or similar.
  • Mark the run as Failed at that step.
• Downstream actions behave according to your error handling:
  • If you didn’t wrap the AI Builder step in Configure run after, the whole flow run is marked Failed.
  • If you did, later actions may still execute but with missing data.

There is no automatic fallback to:

• Copilot Credits
• Non-AI Builder alternatives
• A reduced-quality mode

If the AI Builder action can’t consume credits, it simply fails.

2. Custom document processing models stop scoring

If you trained custom document processing models in AI Builder:

• The models remain visible in AI Builder and in Power Apps/Power Automate.
• You can still open, edit, or retrain models (subject to whatever licensing you still have).
• Calling the model from a flow or app requires AI Builder credits. Without credits, prediction calls fail.

So your AP invoice model doesn’t disappear, but your production flows that call it stop working until capacity is restored.

3. Copilot Credits do not cover AI Builder usage

As of late 2026:

• Copilot Credits apply to Copilot experiences (e.g. Copilot in Power Apps, Power Automate, Power BI, and Microsoft 365 apps) according to the specific licence.
• AI Builder credits are a separate capacity for AI Builder models and actions.
• There is no automatic mapping where Copilot Credits are consumed in place of AI Builder credits for document processing actions.

If your tenant has generous Copilot entitlements but zero AI Builder capacity, your AI Builder document-processing flows still fail.

How to see your AI Builder capacity and usage

Before changing flows, confirm what’s actually happening in your environment.

1. Check AI Builder capacity in the Power Platform admin center

You need an admin role (e.g. Power Platform admin) with access to the tenant or environment.

1. Go to Power Platform admin center.
2. Open Resources > Capacity.
3. Look for AI Builder capacity:
   • Total AI Builder capacity available to the tenant.
   • Capacity assigned to each environment.
4. Confirm whether the environment hosting your AP flows still has AI Builder capacity assigned.

If the environment has 0 AI Builder capacity, any document-processing AI Builder calls from that environment will fail.

2. Inspect flow run history for AI Builder errors

For the AP invoice flow:

1. In Power Automate, open the flow.
2. Go to Run history.
3. Open a failed run after November 1, 2026.
4. Look for the AI Builder action and check the error message.

Common patterns:

• HTTP-like error with a message about quota, capacity, or insufficient credits.
• No outputs from the AI Builder action, causing later steps to fail or process empty data.

This confirms you’re hitting a capacity issue, not a model or data issue.

3. Verify which models are used and where

In AI Builder:

• List the models used in production flows (e.g. your AP invoice model).
• Confirm which environment they’re in.
• Cross-check that environment’s capacity assignment.

This matters if you have multiple environments (Dev/Test/Prod) with different capacity allocations.

Short-term mitigation: keep flows running while you sort licensing

If you’re caught on November 2 with no AI Builder credits and no immediate procurement route, you still want your AP process to run.

The goal: keep the flow functional, even if temporarily less automated, while you add or reassign AI Builder capacity.

1. Add robust error handling around AI Builder actions

Wrap the AI Builder step so the flow can continue when prediction fails.

Approach:

1. Put your AI Builder document-processing action inside a Scope (for example, a scope named Try AI Builder).
2. Add two more scopes: On AI Success and On AI Failure.
3. Use Configure run after:
   • Set On AI Success to run after Try AI Builder is successful.
   • Set On AI Failure to run after Try AI Builder has failed.
4. Inside each scope:
   • In On AI Success, proceed with normal processing using the AI Builder outputs.
   • In On AI Failure, route to a manual fallback.

This doesn’t fix the capacity issue, but it stops the whole flow from failing and gives you a controlled manual path.

2. Route failed documents to a manual queue

In the AP scenario, when AI Builder fails, send the document to a queue for manual data entry.

Typical steps in the On AI Failure path:

• Move the file to a “Manual review” document library or folder.
• Create a record in a tracking list (SharePoint list, Dataverse table, SQL table) with:
  • File URL
  • Trigger timestamp
  • Reason: "AI Builder capacity error"
• Notify the AP team via email or Teams with a link to the list.

This keeps the flow operational and ensures no invoice is silently dropped.

3. Add a capacity health check flow

Build a simple scheduled flow that checks whether AI Builder is usable and alerts admins before business users notice.

Pattern:

• Trigger: Recurrence (e.g. every hour).
• Action: Call a simple AI Builder model (for example, a document processing or text model against a small, static test input).
• If the action fails with a capacity-related error:
  • Send an alert to admins.
  • Optionally write a log entry to a monitoring table.

This doesn’t give you numeric remaining credits, but it acts as a synthetic monitor: "Can AI Builder still run?".

Long-term fix: align licensing, environments, and flow design

Short-term, you’ve prevented outages. Long-term, you want a stable pattern so AI Builder-backed document flows don’t randomly break when capacity changes.

1. Decide where AI Builder is genuinely needed

Not every document-processing use case needs AI Builder.

For the AP team:

• AI Builder is appropriate when:
  • Invoice formats vary significantly.
  • Vendors change layouts frequently.
  • Extraction accuracy from templates or regex would be poor.
• Alternative approaches might be enough when:
  • You have a small, stable set of vendors and layouts.
  • You can enforce standard invoice formats.

If some flows can be reworked to non-AI extraction (e.g. fixed column positions in CSV, structured XML), you reduce your dependency on AI Builder capacity.

2. Centralize AI Builder usage in specific environments

Capacity is assigned per environment. Spreading AI Builder usage across many environments makes it harder to manage.

Practical pattern:

• Use a dedicated Prod environment for AI Builder-heavy flows (e.g. AP, AR, HR document processing).
• Assign AI Builder capacity explicitly to that environment.
• Keep Dev/Test environments with lower or no AI Builder capacity and:
  • Use smaller test datasets.
  • Run fewer scheduled flows.

This concentrates your capacity where it matters and simplifies monitoring.

3. Use environment-level controls and monitoring

If you’re managing multiple teams:

• Regularly review AI Builder usage in the admin center.
• Set up governance so:
  • New AI Builder models and flows are reviewed before production use.
  • Teams understand that each prediction call consumes capacity.

In the AP scenario, you’d:

• Limit invoice processing flows to one or a few standardized patterns.
• Avoid test flows that hammer the same AI Builder model at high frequency.

4. Design flows assuming AI Builder can fail

Even with enough capacity, AI calls can fail for other reasons (service issues, data issues).

For document-processing flows:

• Always treat AI Builder outputs as optional data:
  • Validate outputs before using them downstream.
  • Handle missing or partial results.
• Use Scopes and Configure run after to:
  • Separate AI processing from business logic.
  • Keep business logic robust if AI fails.

This design makes your flows more resilient regardless of capacity.

What you should not expect after November 1, 2026

To avoid incorrect assumptions:

• Do not expect AI Builder document-processing actions to keep running without capacity.
• Do not expect Copilot Credits to automatically cover AI Builder usage.
• Do not expect flows to silently downgrade to a non-AI mode.

If AI Builder credits are gone, document-processing flows that depend on AI Builder will fail at the AI step until capacity is restored or the flow is redesigned.

Practical takeaway: treat AI Builder as a capacity dependency, not a black box

For document-processing flows, "AI Builder credits are gone" is effectively "your extraction engine is offline". The concrete move now is to:

• Audit which production flows depend on AI Builder.
• Add explicit error handling and manual fallbacks around AI actions.
• Concentrate AI Builder usage in environments with assigned capacity and monitor them.

If you treat AI Builder like any other finite compute resource—planned, monitored, and wrapped with fallbacks—your AP invoice processing and similar workflows will survive November 1 and the lack of automatic Copilot Credit transition without nasty surprises.