How Block Cost Configuration Controls Credit Usage in AutoGPT

AutoGPT's block cost configuration defines exactly how many credits each Block consumes by mapping execution units to monetary costs in BLOCK_COSTS, enabling per-request, per-second, or per-byte billing based on runtime context.

The Significant-Gravitas/AutoGPT platform implements a granular credit system where every atomic unit of work—whether an LLM call, image generation, or web search—consumes credits according to a configurable pricing model. The block cost configuration stored in BLOCK_COSTS serves as the single source of truth for these calculations, allowing dynamic pricing based on execution parameters like model selection or runtime duration.

Understanding the Block Cost Configuration Structure

The central registry for pricing lives in autogpt_platform/backend/backend/data/block_cost_config.py. This file maintains the BLOCK_COSTS dictionary, which maps each Block class to a list of BlockCost objects that define when and how to charge users.

The BLOCK_COSTS Registry

Each entry in BLOCK_COSTS associates a Block class with one or more BlockCost instances. When the platform initializes, the SDK registers model-specific costs through autogpt_platform/backend/backend/sdk/cost_integration.py, populating this registry with provider-specific pricing tiers.

BlockCost Parameters

Every BlockCost object contains three critical fields that determine credit consumption:

• cost_type – Defines the billing metric using the BlockCostType enum: RUN (per execution), SECOND (per runtime second), or BYTE (per data size).
• cost_amount – The numeric credit value to deduct.
• cost_filter – Optional criteria dictionary specifying model names, credential IDs, or feature flags that must match the execution context for the cost to apply.

For example, an OpenAI LLM call configuration specifies the model and credentials in the filter while charging per request:

BlockCost(
    cost_type=BlockCostType.RUN,
    cost_filter={
        "model": model,
        "credentials": {
            "id": openai_credentials.id,
            "provider": openai_credentials.provider,
            "type": openai_credentials.type,
        },
    },
    cost_amount=cost,  # Value from MODEL_COST dict

)

Runtime Credit Calculation and Deduction

When a Block executes, the system consults the configuration to determine the exact credit charge. This process involves three stages: cost retrieval, context filtering, and balance adjustment.

Cost Lookup with get_block_cost

The executor calls get_block_cost(block) from autogpt_platform/backend/backend/data/credit.py to retrieve applicable pricing. This function performs a simple dictionary lookup using BLOCK_COSTS.get(type(block)). If the Block class lacks an entry, the function returns an empty list and no credits are charged.

Filter Matching and Context-Aware Pricing

Before applying any charges, the system validates each BlockCost against the current execution context through _is_cost_filter_match. This filtering enables dynamic pricing where the same Block can incur different costs depending on input parameters. A user might pay one rate for GPT-4 and another for GPT-3.5 based on the "model" key in cost_filter.

Credit Deduction by Cost Type

The actual deduction logic resides in autogpt_platform/backend/backend/executor/utils.py. The executor iterates through matched BlockCost objects and calculates the credit delta based on the cost_type:

• RUN – Deducts cost_amount once per execution.
• SECOND – Multiplies cost_amount by the Block's runtime in seconds.
• BYTE – Multiplies cost_amount by the size of processed data in bytes.

The calculated delta passes to credit.adjust_user_balance(user_id, delta), which updates the user's stored balance, enforces credit ceilings, and records the transaction ledger.

Configuring Custom Block Costs

Developers can extend the pricing model by registering new Blocks in block_cost_config.py. The following example configures a custom Block with dual billing: a flat fee per execution plus time-based charges:

# In autogpt_platform/backend/backend/data/block_cost_config.py

from backend.blocks.my_new_block import MyNewBlock
from backend.data.block import BlockCost, BlockCostType

BLOCK_COSTS[MyNewBlock] = [
    BlockCost(
        cost_type=BlockCostType.RUN,    # Charge per execution

        cost_amount=4,                   # 4 credits per run

        cost_filter={},                  # Applies universally

    ),
    BlockCost(
        cost_type=BlockCostType.SECOND,  # Charge per runtime second

        cost_amount=1,                   # 1 credit per second

        cost_filter={},                  # No filtering restrictions

    ),
]

Within the Block implementation, you can inspect these costs during execution:

from backend.data.credit import get_block_cost

class MyNewBlock(Block):
    async def run(self, input_data):
        # Resolve applicable costs for logging or custom handling

        costs = get_block_cost(self)  # Returns list of BlockCost objects

        # Execution logic continues...

Summary

• The block cost configuration in BLOCK_COSTS dictates exactly how many credits each Block consumes during execution.
• Three billing models exist: per-run (RUN), per-second (SECOND), and per-byte (BYTE), configurable via BlockCostType.
• Context-aware filtering through cost_filter allows dynamic pricing based on model selection, credentials, or execution flags.
• Runtime deduction occurs in executor/utils.py via adjust_user_balance(), which updates user credit balances immediately after cost calculation.
• Modifying BLOCK_COSTS instantly changes credit consumption across the platform without requiring code changes to individual Blocks.

Frequently Asked Questions

What happens if a Block isn't registered in BLOCK_COSTS?

If get_block_cost() cannot find the Block class in BLOCK_COSTS, it returns an empty list. The executor charges zero credits for that execution, making the Block effectively free. This behavior allows development and testing without immediate pricing configuration.

How does AutoGPT handle different pricing for different LLM models?

The cost_filter dictionary in BlockCost objects includes a "model" key that must match the current execution's selected model. When running an LLM Block, the executor filters the available costs and only applies those matching the specific model and credentials, enabling per-model pricing tiers within the same Block class.

Can I set time-based charges for custom blocks?

Yes. Set cost_type=BlockCostType.SECOND in your BlockCost configuration with a cost_amount representing credits per second. During execution, the system measures the Block's runtime and multiplies the duration by this rate before deducting from the user's balance.

Where is the user credit balance stored and updated?

The adjust_user_balance() function in autogpt_platform/backend/backend/data/credit.py handles all credit mutations. This function updates the persistent user balance, enforces maximum credit limits, and records transaction history for auditing purposes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}