Cost Risk

Overview

Cost Risk measures where AI and API spend can multiply unexpectedly — loops, retries, oversized prompts, and agents with no bound on how much they call out. None of these findings state a dollar amount; FlowScan doesn't see your pricing or execution volume. What it reports is the structural pattern that makes spend scale faster than anyone intended.

How this affects your score

Cost Risk is weighted 0.20 — the second-heaviest category after Reliability. Findings here range from medium to critical severity, with critical reserved for combinations (a premium model, in a loop, with no output cap, is worse than any one of those alone).

Worked example: a workflow with one high-severity finding (an LLM call inside an item loop) and one medium-severity finding (a premium model used for a simple task) scores 100 − 15 − 8 = 77 on Cost Risk, contributing 77 × 0.20 = 15.4 points toward the total.

Cost Risk also has a second, independent number attached to it — the Cost Exposure Score — described below, which can flag a workflow as high-risk even when the category health score looks reasonable.

Findings

Loop and volume multipliers

• An LLM call sitting inside an item loop. If the loop processes 200 items, that's 200 model calls, not one. Example: a workflow loops over rows in a spreadsheet and calls an AI node once per row to classify each one; a 500-row spreadsheet means 500 model calls on a single run. Fix: batch the items into a single call where the model can handle multiple records at once, or move the AI call outside the loop if it doesn't actually need per-item context.
• A loop used where the target service already supports batch operations. Looping one record at a time multiplies request count for no benefit when a bulk endpoint exists. Fix: switch to the batch/bulk operation the destination API provides.
• A repeated read inside a loop that never changes. Re-fetching the same reference data on every iteration instead of once. Fix: move the read outside the loop and reuse the result.
• A loop body that calls an external or messaging service per item. Beyond the direct cost multiplier, this is how rate limits get hit — iteration count becomes request count to a third party. Fix: batch the calls or add throttling between iterations.

Prompt and data volume

• A full JSON object dumped into a prompt instead of trimmed fields. Inflates token count on every call without improving the model's output. Example: a prompt includes the entire API response object (dozens of fields) when the model only needs three of them. Fix: map only the fields the prompt actually references before constructing it.
• A full JSON object mapped into another node's input instead of specific fields. Same waste without the AI angle — moving more data than a step needs costs time and, on some platforms, operation-based billing.
• A single node concentrating a large volume of data before an AI or write step. A "fetch everything, then process" pattern with no filtering or pagination — the downstream step pays for however much the fetch returns. Fix: filter or paginate at the fetch, not after.

AI call and agent controls

• No token or output limit on an AI call. A single verbose response can cost far more than expected, and the effect compounds if the call also sits inside a loop or behind a high-frequency trigger. Fix: set an explicit max-tokens or output limit on every AI call.
• A premium model used for a simple task. Classification, extraction, and short transforms rarely need the most capable model available. Example: a node classifies incoming support tickets into five categories using the most expensive model tier, when a smaller model handles this reliably. Fix: switch to a lower-tier model for well-scoped, low-complexity tasks — this is usually the cheapest fix on the list.
• An AI agent with no iteration limit. Agents can call tools repeatedly while reasoning toward a goal; without a cap, one request can spiral into dozens of tool calls before it resolves or gives up. Fix: set a maximum iteration count on the agent's configuration.
• Multiple LLM calls chained back-to-back. Each model's output becomes the next model's input, and each hop adds its own prompt overhead on top of an already-growing context. Fix: consolidate into fewer calls where the same result can be reached in one pass, or trim the intermediate output before passing it forward.

Trigger and polling patterns

• A high-frequency trigger feeding an expensive downstream call. A schedule firing every minute wired directly into an AI call or paid API, with no filtering in between, means that call runs 1,440 times a day whether or not there's anything new to process. Fix: add a filter or change-detection step before the expensive call so it only fires when there's actual new work.
• A polling trigger with no filter. Fetches everything on every run instead of only what changed since last time. Fix: use a delta parameter (a timestamp or cursor) so each poll only returns new records.

Cost Exposure Score

The Cost Risk score above is a 0–100 health score. The Cost Exposure Score is a separate, independent number built from the same underlying signals, scored differently: 12 factors — model tier risk, prompt size risk, loop multiplier risk, retry multiplier risk, agent iteration risk, agent tool-call risk, output-bound risk, data concentration risk, unnecessary-loop risk, high-frequency-trigger risk, chained-LLM risk, and poll-without-filter risk — each rated 0–3, for a combined maximum of 36. Higher means worse here, the opposite direction from the health score above.

This exists because a health score can only subtract so much per finding, which flattens combinations. A workflow with a premium model inside a loop, no output cap, and no agent iteration limit has three multipliers stacked on each other — a materially worse spend profile than any one issue alone, even if the category deduction looks similar. Bands: 0–2 low, 3–5 medium, 6–9 high, 10+ critical.

If your Cost Risk score looks reasonable but your Cost Exposure Score sits in the high or critical band, that's the signal that several small multipliers are stacking rather than one obvious one.

Recommended fixes

1. Move any AI call out of an item loop, or batch the items into fewer calls — this is the single highest-leverage fix, since loop multipliers compound with every other issue on this list.
2. Set a token/output limit on every AI call that's missing one.
3. Set an iteration limit on every agent that's missing one.
4. Trim prompts and node inputs to the specific fields needed instead of passing full objects.
5. Swap premium models for a lower tier on simple, well-scoped tasks — the cheapest fix, worth doing even when it's not the highest priority.
6. Add filtering before high-frequency triggers and polling reads.

Related categories

• AI Governance — agent iteration limits and tool access, viewed as autonomy risk rather than spend
• Reliability — nested loops and chain failure risk overlap directly with cost multipliers
• Overview — full detail on how the Cost Exposure Score's 12 factors are calculated