Agent Resource Consumption Summary Prompt Template

This prompt is designed for platform operators and AI cost engineers who need to generate a structured, per-session or per-task resource consumption report from raw agent execution traces. It takes a trace log containing token counts, tool call metadata, latency measurements, and session identifiers, and produces a summary with total tokens consumed, tool calls broken down by type, cumulative latency, estimated cost, and attribution to the correct session. Use this when you need to feed consumption data into internal dashboards, chargeback systems, or cost optimization reviews.

The ideal input is a structured trace log, not a raw stream of unstructured events. The prompt expects fields like session_id, timestamp, tool_name, tokens_in, tokens_out, latency_ms, and model_id to be present and normalized before the prompt is invoked. If your traces are missing these fields, you must pre-process them. The prompt will not reliably infer missing identifiers or correct inconsistent timestamp formats. For high-stakes financial reporting, always validate the output against a known source of truth, such as your model provider's official usage dashboard, before feeding it into a chargeback pipeline.

Do not use this prompt for real-time budget enforcement during active agent execution; it is a post-hoc reporting tool, not an in-line circuit breaker. It is also unsuitable for generating per-user invoices that require legal-grade accuracy without human review. If you are operating in a multi-tenant environment where session IDs could collide across organizations, ensure your trace data includes a tenant identifier and that the prompt's attribution logic is tested against cross-tenant contamination scenarios. The next section provides the copy-ready template you can adapt to your specific trace schema and cost model.

This template instructs the model to produce a structured resource consumption summary from raw agent execution traces. It is designed for platform operators who need per-session or per-task reports that attribute token usage, tool calls, latency, and estimated cost to specific agent actions. The prompt enforces a strict output schema so the summary can be ingested directly into billing systems, cost dashboards, or audit logs without manual reformatting.

textCopy
You are an AI cost auditor. Generate a resource consumption summary from the agent trace data and pricing configuration provided below.

[TRACE_DATA]

[PRICING_CONFIG]

[OUTPUT_SCHEMA]

[CONSTRAINTS]

[EXAMPLES]

Replace each placeholder with your operational data. [TRACE_DATA] should contain the raw execution log, including timestamps, model names, token counts, tool names, and call durations. [PRICING_CONFIG] must specify per-token and per-call costs for each model and tool in the trace. [OUTPUT_SCHEMA] defines the exact JSON structure you expect—include fields for session_id, total_tokens, total_tool_calls, total_latency_ms, estimated_cost, and a line_items array with per-action attribution. [CONSTRAINTS] should list rules such as rounding precision, currency format, and how to handle missing pricing data. [EXAMPLES] should contain one or two correct input-output pairs to anchor the model's behavior.

Before wiring this into production, validate the output against your schema in a test harness. Common failure modes include misattributing tool calls to the wrong session when traces contain interleaved concurrent sessions, double-counting tokens when a tool call's prompt and completion are logged separately, and applying incorrect pricing tiers when models have graduated rates. Run the prompt against at least 20 real production traces and compare the summaries to your existing cost accounting. If the variance exceeds 2%, add more explicit attribution rules to [CONSTRAINTS] and retest. For high-stakes billing workflows, always route summaries with cost anomalies above a threshold to a human reviewer before they reach downstream systems.

This prompt is designed to be called at the end of an agent session or task, consuming structured trace data to produce a human-readable and machine-parseable summary. The primary integration point is your agent framework's on_session_end or on_task_complete hook. You will need to aggregate raw telemetry—token counts, tool call records with timestamps and latency, and any cost metadata—into a structured [TRACE_DATA] object before invoking the model. Do not pass raw log lines; the prompt expects pre-aggregated fields to minimize token waste and hallucination risk.

Input assembly: Build [TRACE_DATA] as a JSON object containing session_id, start_time, end_time, models_used (array of {model_name, total_prompt_tokens, total_completion_tokens, estimated_cost}), tool_calls (array of {tool_name, call_count, total_latency_ms, total_tokens, estimated_cost}), and rate_limit_events (array of {tool_name, retry_count, total_wait_ms}). If your platform uses per-call pricing, pre-calculate estimated_cost fields before prompt assembly. For multi-tenant systems, include a tenant_id or chargeback_tag in the trace object. Validation gate: Before calling the LLM, validate that total_tokens across models and tools sums to a non-zero value and that start_time precedes end_time. Reject malformed traces with a structured error rather than asking the model to fix them.

Model choice and output handling: Use a fast, cost-efficient model (e.g., GPT-4o-mini, Claude Haiku) for this summarization task—the reasoning demand is low, and you want to avoid spending significant compute on cost reporting. Set temperature=0 to ensure deterministic output. Request a JSON output mode with a strict schema. After receiving the response, validate that total_cost in the summary matches the sum of estimated_cost fields from your input trace within a 1% tolerance. If validation fails, log the mismatch, append the validator error to [TRACE_DATA], and retry once. If the retry also fails, emit a partial summary with a validation_warning flag set to true and route for human review. Logging: Store the raw trace, the generated summary, and the validation result in your observability platform for audit and spend anomaly detection.

Multi-session and concurrency considerations: When summarizing across concurrent agent sessions, ensure each session's trace is isolated by session_id. Do not batch multiple sessions into a single prompt call unless you explicitly include a sessions array in [TRACE_DATA] and adjust the output schema to produce per-session summaries. For high-throughput systems, consider asynchronous generation: enqueue completed traces to a summary worker pool, generate summaries out-of-band, and store results for later retrieval. This avoids adding LLM latency to the user-facing session close path. What to avoid: Never pass raw API response logs or unaggregated event streams as [TRACE_DATA]; the model will miscount tokens, hallucinate costs, or miss rate-limit events. Always pre-compute aggregates in your application layer before prompt assembly.