Task-level outcome and usage history for model efficiency analysis

What feature would you like to see?

I would like Codex to provide a user-visible history that connects task-level usage with task outcomes.

Existing usage analytics help answer:

What consumed my Codex usage?

But I would also like to answer:

What result did I get for that usage, and which model has been most efficient for similar work?

For example:

Task: Issue #35 – Add AI search
Model: Model X
Charged usage: 6.8%
Duration: 24 min
Retries: 1
Tests: 42/42 passed
Result: Completed

Compared with:

Task: Issue #41 – Similar feature
Model: Model Y
Charged usage: 10.2%
Duration: 41 min
Retries: 3
Tests: 42/42 passed
Result: Completed

Over time, this history would let users compare the real efficiency of models on their own workloads.

A smaller or cheaper model is not necessarily more efficient if it requires repeated retries. Likewise, a frontier model may be unnecessary for routine work.

Proposed feature

As a first version, Codex could retain and expose task-level metadata such as:

• Project
• Task / thread
• Model
• Charged usage units or equivalent normalized usage
• Duration
• Retry count
• Completion status
• Test result, when available

The important part is that these fields are stored together as a task outcome record, rather than only appearing as aggregate usage statistics.

A history view might look like:

Task              Model     Usage    Retries    Tests       Result
Issue #35         Model X   6.8%     1          42/42       Completed
Issue #41         Model Y   10.2%    3          42/42       Completed
Bug fix #52       Model X   2.1%     0          18/18       Completed

Model efficiency analysis

Once enough task history exists, Codex could optionally aggregate it by model and workload type:

Similar implementation tasks

Model X
Average usage: 6.4%
Completion rate: 94%
Average retries: 0.8

Model Y
Average usage: 9.1%
Completion rate: 91%
Average retries: 2.1

This does not need to automatically select a model.

The initial value would simply be giving users enough evidence to make that decision themselves.

Why this would be useful

Generic benchmarks do not necessarily reflect a user's real projects.

Model efficiency depends on:

• the codebase;
• task type;
• context size;
• prompting/delegation style;
• retries;
• verification requirements;
• and whether the task actually completed successfully.

A task-level outcome history would therefore allow users to build an empirical model-selection strategy based on their own work.

For teams, the same information could also help evaluate the efficiency of AI-assisted development workloads.

Related issues

This proposal is related to several existing requests:

• #5085 – Cost Tracking & Usage Analytics
• #19034 – Real usage analytics
• #28985 – Account-wide Codex usage attribution by client, session, and timestamp
• #34278 – Per-thread Auto mode that routes both model and reasoning effort
• #34388 – Smart Mode for automatic model and reasoning-effort selection

#28985 focuses on identifying what consumed usage and where.

#34278 and #34388 focus on routing or selecting models and reasoning effort.

This proposal focuses on a different layer:

preserving user-visible historical evidence of task + model + usage + outcome, so users can compare model efficiency from actual completed work.

That history could later become useful input for automatic routing, but automatic model selection is not required for the initial implementation.

Possible phased implementation

Phase 1 — Task outcome history

Expose task/model/usage/duration/retry/completion/test metadata.

Phase 2 — Model and workload comparison

Aggregate historical task results by model and workload category.

Phase 3 — Optional recommendations

Use similar past tasks to suggest an efficient model.

The MVP would stop at Phase 1 and would not require automatic model routing.