Cost Per Successful Task

The sum of all computational and financial expenditures for a set of agent tasks. This is the numerator in the CPST calculation.

Key cost drivers include:

• Token Consumption: Costs from the language model's input and output tokens.
• External API Calls: Fees for tool calls, data retrieval, or other third-party services.
• Compute Infrastructure: Costs for the runtime environment, vector database queries, and memory operations.

Accurate telemetry must attribute costs to specific agent sessions and individual actions for precise calculation.

The denominator in the CPST formula. A task is counted as successful only if it meets all pre-defined success criteria, which must be objectively verifiable.

Common criteria include:

• Functional Correctness: The output matches the expected result or passes automated validation.
• Policy Compliance: The agent's actions and outputs adhere to all safety and operational guardrails.
• Constraint Adherence: The task is completed within specified limits for time, budget, or resource usage.

This count excludes tasks that fail, are incomplete, or violate constraints, ensuring the metric reflects cost efficiency for quality outputs.

The observability pipeline that captures, tags, and aggregates cost data at the granularity required for CPST calculation. This involves instrumenting the agent's execution to track:

• Per-Session Costs: Aggregating all expenses for a single task execution from start to finish.
• Per-Action Breakdown: Isolating costs for specific steps (e.g., planning call vs. tool execution).
• Provider-Level Detail: Separating costs by vendor (e.g., OpenAI, Anthropic, AWS) for analysis.

Without robust agent cost telemetry, CPST becomes an unreliable average, masking inefficiencies in specific agent components or workflows.

The explicit, measurable conditions that determine if a task outcome qualifies for the 'successful' count. Vague criteria render CPST meaningless.

Criteria are typically implemented as:

• Automated Evaluators: Rule-based checks or model-based scorers that validate outputs against a schema or ground truth.
• Guardrail Checks: Verification that the agent's reasoning trace and actions did not trigger any safety or policy violations.
• Business Logic Validation: Confirmation that the result achieves the intended business outcome (e.g., a correctly booked calendar event, a resolved support ticket).

Clear criteria align CPST with business objectives, not just technical completion.

CPST should be analyzed alongside other Agentic SLIs that provide context for cost drivers and efficiency.

• Redundant Action Ratio: A high ratio indicates planning inefficiencies that inflate costs.
• Action Success Ratio: A low ratio means failed tool calls incur cost without progress, raising CPST.
• Self-Correction Success Rate: Effective self-correction can reduce costs by avoiding human-in-the-loop interventions.
• End-to-End Task Latency: While not a direct cost, high latency often correlates with higher compute resource consumption.

Monitoring these SLIs holistically helps diagnose the root causes of high CPST.

CPST serves as a core metric for the financial operations of autonomous agent systems, enabling:

• Budget Forecasting: Predicting costs based on projected task volumes and target CPST.
• Cost Optimization: Identifying and prioritizing improvements to agent architecture, prompts, or tool usage to lower CPST.
• Vendor Analysis: Comparing the CPST of agents using different foundation models or APIs to inform procurement.
• ROI Calculation: Quantifying the value delivered per dollar spent by the agent system, especially when compared to manual execution costs.

It translates technical agent performance into a direct financial KPI for CTOs and engineering leaders.

An Agentic SLI is a quantitative measure of a specific aspect of an autonomous agent's performance. It forms the foundation of observability, providing the raw data for assessing operational health.

• Examples: Planning Success Rate, End-to-End Task Latency, and Cost Per Successful Task.
• Purpose: To objectively track performance over time and detect deviations from normal behavior.
• Implementation: Typically measured as a ratio, average, or percentile over a sliding time window.

An Agentic SLO is a target value or range for an Agentic Service Level Indicator (SLI). It defines the acceptable level of performance for an autonomous agent system over a specified period, creating a formal reliability contract.

• Example: "Cost Per Successful Task shall be ≤ $0.15 for 99% of tasks over a 30-day rolling window."
• Relationship to SLI: An SLO is applied to an SLI. The SLI is the measurement; the SLO is the target for that measurement.
• Business Function: SLOs balance reliability with innovation by defining an explicit Error Budget.

An Error Budget is the allowable amount of time an autonomous agent system can fail to meet its Service Level Objectives (SLOs) within a defined compliance period. It is calculated as (1 - SLO%) * Measurement Period.

• Function: It quantifies acceptable unreliability, enabling teams to make data-driven decisions about deploying risky features or improvements.
• Example: With a 99.9% monthly SLO, the error budget is 43.2 minutes of failure time per month.
• Burn Rate: The speed at which the error budget is consumed. A high burn rate triggers urgent investigation.

Agent Cost Telemetry refers to the instrumentation and data pipelines that track and attribute computational and financial costs to individual agent sessions, actions, or tasks. It is the observability foundation for calculating Cost Per Successful Task.

• Data Sources: Token usage from LLM APIs, compute time, external API call costs, and memory/GPU utilization.
• Key Challenge: Accurate attribution of shared or distributed costs across multi-step agent workflows.
• Output: Granular cost data that feeds into SLI calculations and FinOps reporting.

Task Completion Rate is an Agentic SLI that measures the percentage of assigned tasks an autonomous agent successfully finishes within defined operational constraints (time, correctness). It is a core measure of agent effectiveness.

• Calculation: (Number of Successfully Completed Tasks / Total Tasks Attempted) * 100.
• Relationship to Cost: A low Task Completion Rate directly inflates the Cost Per Successful Task, as failed attempts incur cost without delivering value.
• Nuance: Requires a precise, automated definition of "successful completion" for the specific task domain.

A Composite SLI is a Service Level Indicator derived from the mathematical combination of two or more underlying Agentic SLIs. It provides a unified score for a complex aspect of agent performance, such as overall efficiency or safety.

• Purpose: To simplify complex system health into a single, actionable metric.
• Example: An Efficiency Score combining Cost Per Successful Task (weighted for cost) and End-to-End Task Latency (weighted for speed).
• Construction: Often uses weighted averages, min/max functions, or other formulas to combine normalized SLI values.