Budget Check

Budget Check asks whether the model call ahead would be allowed, before any money is held. When the answer is yes, the execution goes on to the call. When it is no, the execution takes the Deny branch, and the flow decides what the caller hears.

What it does

The node estimates the call of the AI Model node its chain leads to, as the hold of that call will be estimated. Then it checks the call in one of two ways, set by Budget to check.

• Global policy, the way a new node checks. The node evaluates the policies and reads the money budgets that bind the call: those of the organization, the project, the operation and your customer. When the hold would fit, the execution leaves through Allow. When a policy refuses, or a budget has no room for the hold, it leaves through Deny with policy_denied or budget_exceeded.

• The allocation of the node. The node first checks as above, and that refusal wins. Then it checks the call against a limit of its own for the model the chain leads to: what the calls past this node have cost, counted by their estimates, together with the hold of this call, must stay within the limit. A model with no line of its own takes the default limit, and with no default limit it passes without one. A refusal of the allocation takes Deny with budget_exceeded.

The node reads and holds nothing. Three limits are left to the model call, which checks them when it takes its hold: a budget Per operation, the Concurrent holds of a budget, and the credits of your customer. That is why AI Model has a Deny port of its own. Under load the node may also let through a call whose hold is then refused.

When the call cannot be estimated, the node lets the execution through, and the model call decides.

When to use it

• To refuse before money is held and to choose what follows: a cheaper model through Fallback, an answer from the cache, a refusal with a code of your own through Reject Request.

• To give one flow a share of the money for each model, apart from the budgets of the project: set the allocation of the node.

• The budgets themselves are set on Budgets — Budgets. The node reads them, it does not replace them.

A refusal of this node sends no webhook event. operation.denied is sent when the model call itself is refused on a policy or a budget.

An execution that ends rejected after the node refused keeps the estimate of the refused call as its cost.estimated: money the refusal saved, not money spent. A Deny branch that answers without calling a model ends completed with the same estimate and no actual cost.

Settings

In the builder Budget to check chooses between Global policy and the allocation of the node. With the allocation chosen, Window sets the period a limit is counted in, and Add allocation adds a line: a model and its limit. The panel marks the line in force — the one of the model the node leads to. The default limit, for a model without a line, is optional.

What the allocation counts belongs to this node of this flow and to one model and window. A limit is a decimal number with a dot and no currency sign, such as 25.00.

Ports

When Deny has no connection, the refusal is the answer to the request: the caller gets budget_exceeded or policy_denied, and the execution ends as rejected. The publish check warns about such a node — Ports and branching.

Output

When the call would be allowed, the node leaves what it read:

{
  "allowed": true,
  "available": "24.50000000",
  "would_reserve": "0.00057600",
  "node_budget": "within_limit",
  "node_budget_limit": "25.00000000",
  "node_budget_spent": "3.12000000"
}

• would_reserve is the hold the call would take, and available is what is left in the tightest budget that binds the call. available is absent when no budget binds it.

• The three node_budget fields are there only with the allocation. node_budget says how the allocation was read: within the limit here, and otherwise that the model has no line or that the call could not be estimated.

When the node refuses, denied_by says who refused — the policies and budgets, or the allocation of the node:

{ "allowed": false, "error_code": "budget_exceeded", "denied_by": "policy" }

{ "allowed": false, "error_code": "node_budget_exceeded", "denied_by": "node_allocation" }

A Condition on the Deny branch reads them by the path nodes.<key>.output.denied_by, where <key> is the key of this node in the flow. The code the caller gets for a refused allocation is budget_exceeded; node_budget_exceeded stays in the output and the trace.

Errors

The settings of the node are checked when the flow is validated and when it is published.

The place of the node is checked too: it leads to exactly one AI Model — The money chain.

Example

Budget Check asks whether the call fits. When it does, AI Model holds the money and calls the model. When it does not, Reject Request ends the request with the code its author chose, and no money was held.

Related

• The money chain — the nodes around a model call and the order they stand in.

• Budgets — the budgets the node reads.

• Policies — the rules that can refuse a call.

• When spend is refused — what your application gets for a refused request.