@@ -50,7 +50,7 @@ These views support `--json`, `--compact`, `--offline`, and `--speed auto|standa
 - **Per-model grouping** – The active `turn_context` specifies the model for newly counted usage. Replayed parent contexts in current MultiAgent V2 subagent prefixes remain inherited history and do not add model usage to the child. We aggregate tokens per day/month and per model. Sessions lacking model metadata (seen in early September 2025 builds) are skipped.
 - **Pricing** – Rates come from LiteLLM's pricing dataset via the shared `LiteLLMPricingFetcher`. Codex's internal review label uses the manually curated, date-based fallback timeline below and remains marked as approximate.
 - **Scheduled pricing** – DeepSeek V4 Flash and Pro use each event's timestamp: legacy rates apply before `2026-08-16T16:00:00Z`, and the later rates use UTC weekday peak windows of `01:00–04:00` and `06:00–10:00` (endpoints excluded). Cache creation follows the scheduled input rate.
-- **Speed pricing** uses `--speed auto` by default. For rollouts written by Codex CLI 0.144.0 and later, ccusage applies recorded `thread_settings_applied` tier changes chronologically. `priority` and legacy `fast` use Fast pricing, `flex` uses Flex pricing, and `default` or `standard` uses Standard pricing. Unmarked usage falls back to `config.toml` detection. Pass `--speed standard`, `--speed flex`, or `--speed fast` to override every recorded tier. Fast and Flex pricing use model-specific multipliers only when one is available; otherwise, ccusage keeps standard pricing rather than inventing a rate.
+- **Speed pricing** uses `--speed auto` by default. For rollouts written by Codex CLI 0.144.0 and later, ccusage applies recorded `thread_settings_applied` tier changes chronologically. `priority` and legacy `fast` use Fast pricing, `ultrafast` uses Ultrafast pricing, `flex` uses Flex pricing, and `default` or `standard` uses Standard pricing. Unmarked usage falls back to `config.toml` detection. Pass `--speed standard`, `--speed flex`, or `--speed fast` to override every recorded tier. Ultrafast pricing applies only to usage recorded with the `ultrafast` tier; there is no `--speed ultrafast` option or `ultrafastMultiplier` pricing override. Fast and Flex pricing use model-specific multipliers only when one is available; otherwise, ccusage keeps standard pricing rather than inventing a rate.
 - **Legacy fallback** – Early September 2025 logs that never recorded `turn_context` metadata are still included; the CLI assumes `gpt-5` for pricing so you can review the tokens even though the model tag is missing (the JSON output also marks these rows with `"isFallback": true`).
 - **Cost formula** – Non-cached input uses the standard input price; cached input uses the cache-read price (falling back to the input price when missing); and output tokens are billed at the output price. All prices are per million tokens. Reasoning tokens may be shown for reference, but they are part of the output charge and are not billed separately.
 - **Totals and reports** – Daily, monthly, and session views display per-model breakdowns, overall totals, and optional JSON for automation.
@@ -68,13 +68,13 @@ When Codex emits a model alias, the CLI automatically resolves it through the Li
 
 ## Speed Pricing
 
-By default, `ccusage codex` uses `--speed auto`. Codex CLI 0.144.0 and later can persist `thread_settings_applied` events in session rollouts. ccusage associates each token event with the most recent recognized setting. `service_tier = "priority"` or legacy `"fast"` is Fast, `"flex"` is Flex, and `"default"` or `"standard"` is Standard. This supports sessions that switch modes over time instead of applying one multiplier to the entire day or session.
+By default, `ccusage codex` uses `--speed auto`. Codex CLI 0.144.0 and later can persist `thread_settings_applied` events in session rollouts. ccusage associates each token event with the most recent recognized setting. `service_tier = "priority"` or legacy `"fast"` is Fast, `"ultrafast"` is Ultrafast, `"flex"` is Flex, and `"default"` or `"standard"` is Standard. This supports sessions that switch modes over time instead of applying one multiplier to the entire day or session.
 
-Some usage remains unclassified, including older rollouts, saved headless `codex exec --json` output, and startup usage before the first persisted settings event. For only that unclassified portion, auto mode reads `config.toml` from each `CODEX_HOME` root and uses Fast when any root has `service_tier = "priority"` or legacy `service_tier = "fast"`. If no root requests Fast and a root requests `service_tier = "flex"`, it uses Flex. Otherwise it uses Standard. An unsupported recorded tier is also left unclassified rather than inheriting a stale tier. Explicit `--speed standard`, `--speed flex`, and `--speed fast` override all recorded and fallback tiers.
+Some usage remains unclassified, including older rollouts, saved headless `codex exec --json` output, and startup usage before the first persisted settings event. For only that unclassified portion, auto mode reads `config.toml` from each `CODEX_HOME` root and uses Fast when any root has `service_tier = "priority"` or legacy `service_tier = "fast"`. If no root requests Fast and a root requests `service_tier = "flex"`, it uses Flex. Otherwise it uses Standard. A configured `service_tier = "ultrafast"` is ignored for unclassified usage, so it stays Standard unless another root requests Fast or Flex. An unsupported recorded tier is also left unclassified rather than inheriting a stale tier. Explicit `--speed standard`, `--speed flex`, and `--speed fast` override all recorded and fallback tiers.
 
 Fallback detection reads the top-level `service_tier` and lets a named profile override it only when `profile = "name"` selects that profile in `config.toml`. Inactive profiles are ignored, and a selected profile without its own tier inherits the top-level setting. If Codex selected a profile through `--profile` or another configuration file, use an explicit `--speed` for unclassified usage because ccusage cannot infer that selection from `config.toml`.
 
-Fast and Flex pricing use model-specific multipliers only when one is published. GPT-5.6 Sol, Terra, and Luna use the [documented 2× API Priority rate](https://learn.chatgpt.com/docs/agent-configuration/speed#fast-mode), and GPT-6 [Astra](https://developers.openai.com/api/docs/models/gpt-6-astra), [Sol](https://developers.openai.com/api/docs/models/gpt-6-sol), and [Luna](https://developers.openai.com/api/docs/models/gpt-6-luna) and GPT-6.1 [Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and [Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra) use their documented 2× Fast rates. Models listed in OpenAI's [Flex pricing table](https://developers.openai.com/api/docs/pricing) use 0.5× Standard pricing, including dated and provider-qualified names. These are distinct from ChatGPT credit-consumption rates. ccusage's `costUSD` is an API-equivalent estimate, not a ChatGPT credit balance. When a model's Fast or Flex rate is unknown, ccusage reports standard pricing rather than assuming a multiplier, which may underestimate Fast usage or overestimate Flex usage.
+Fast and Flex pricing use model-specific multipliers only when one is published. GPT-5.6 Sol, Terra, and Luna use the [documented 2× API Priority rate](https://learn.chatgpt.com/docs/agent-configuration/speed#fast-mode), and GPT-6 [Astra](https://developers.openai.com/api/docs/models/gpt-6-astra), [Sol](https://developers.openai.com/api/docs/models/gpt-6-sol), and [Luna](https://developers.openai.com/api/docs/models/gpt-6-luna) and GPT-6.1 [Sol](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and [Terra](https://developers.openai.com/api/docs/models/gpt-6.1-terra) use their documented 2× Fast rates. Models listed in OpenAI's [Flex pricing table](https://developers.openai.com/api/docs/pricing) use 0.5× Standard pricing, including dated and provider-qualified names. Recorded Ultrafast usage uses the 6× Standard rates in the same table's Ultrafast section, which covers GPT-6.1 Sol and GPT-6 Astra; other models keep Standard pricing for Ultrafast requests. These are distinct from ChatGPT credit-consumption rates. ccusage's `costUSD` is an API-equivalent estimate, not a ChatGPT credit balance. When a model's Fast or Flex rate is unknown, ccusage reports standard pricing rather than assuming a multiplier, which may underestimate Fast usage or overestimate Flex usage.
 
 Use [`pricingOverrides`](/guide/config-files#pricing-overrides) to configure a model's `fastMultiplier` or `flexMultiplier`.
 
 
@@ -443,10 +443,11 @@ Keys in `pricingOverrides` should match the model label reported by ccusage, inc
 
 To find the exact name, run `ccusage <agent> daily --json` and look at the `model` field in the per-row breakdown.
 Pi also accepts a bare model name as an override key; that key applies to the default store and any named Pi store using the same model. Use the prefixed label to price one store separately.
+If a key has no pricing entry of its own but is a model alias, unspecified fields come from the alias target's entry.
 
 ### Supported Fields
 
-All fields are optional. Unspecified fields keep existing values. Without a pricing entry, token rates default to `0.0` and speed multipliers to `1.0`.
+All fields are optional. Unspecified fields keep existing values. Without a pricing entry, token rates default to `0.0`, and speed multipliers use the published Fast, Flex, or Ultrafast rate for that model name or its alias target, or `1.0` if none is published.
 
 - `inputCostPerToken`, `outputCostPerToken` — base per-token rates
 - `cacheCreationInputTokenCost`, `cacheReadInputTokenCost` — cache pricing
@@ -455,6 +456,8 @@ All fields are optional. Unspecified fields keep existing values. Without a pric
 - `fastMultiplier` applies when Codex usage uses Fast pricing.
 - `flexMultiplier` applies when Codex usage uses Flex pricing.
 
+The Ultrafast multiplier comes only from published rates and cannot be set in `pricingOverrides`; there is no `ultrafastMultiplier` field.
+
 ### Overrides vs Offline Mode
 
 `--offline` and `pricingOverrides` are independent:
 
@@ -88,6 +88,7 @@ let
     lib.optionals (lib.elem "ccusage-core" names) [
       (rustRoot + /crates/ccusage-core/src/fast-multiplier-overrides.json)
       (rustRoot + /crates/ccusage-core/src/flex-multiplier-overrides.json)
+      (rustRoot + /crates/ccusage-core/src/ultrafast-multiplier-overrides.json)
     ]
     ++ lib.optionals (lib.elem "ccusage-adapter-codex" names) [
       (rustRoot + /adapters/codex/src/codex-auto-review-fallbacks.json)
 
@@ -27,6 +27,7 @@ let
       || lib.hasSuffix "/cli-commands.json" path
       || lib.hasSuffix "/fast-multiplier-overrides.json" path
       || lib.hasSuffix "/flex-multiplier-overrides.json" path
+      || lib.hasSuffix "/ultrafast-multiplier-overrides.json" path
       || lib.hasSuffix "/models-dev-pricing.json" path
       || lib.hasSuffix "/models-dev-catalog-rules.json" path
       || lib.hasSuffix "/codex-auto-review-fallbacks.json" path;
 
@@ -36,6 +36,7 @@ Relevant speed-setting event in Codex CLI 0.144.0 and later:
 - `payload.type === "thread_settings_applied"`
 - `payload.thread_settings.service_tier === "priority"` (or legacy `"fast"`) selects Fast.
 - `payload.thread_settings.service_tier === "flex"` selects Flex.
+- `payload.thread_settings.service_tier === "ultrafast"` selects Ultrafast.
 - `payload.thread_settings.service_tier === "default"` selects Standard. Codex Desktop spells the same tier `"standard"`; both appear in the same CLI version, so this is a value mapping and not a version split.
 - Token usage inherits the latest recognized setting in the rollout. A settings event without a `service_tier` key leaves the previous tier in place (auto-review threads emit these); a tier that is present but unrecognized clears it so a stale value is not inherited.
 - `thread_settings_applied` is not emitted per turn, so short rollouts carry no tier at all and stay unclassified for report policy to resolve.
 
@@ -502,6 +502,9 @@ fn accumulate_codex_event_into_model_usage(
                 }
                 Some(CodexServiceTier::Fast) => Some(&mut timestamped_usage.recorded_fast_usage),
                 Some(CodexServiceTier::Flex) => Some(&mut timestamped_usage.recorded_flex_usage),
+                Some(CodexServiceTier::Ultrafast) => {
+                    Some(&mut timestamped_usage.recorded_ultrafast_usage)
+                }
                 None => None,
             };
             if let Some(recorded_usage) = recorded_usage {
@@ -514,6 +517,7 @@ fn accumulate_codex_event_into_model_usage(
             Some(CodexServiceTier::Standard) => Some(&mut model_usage.recorded_standard_usage),
             Some(CodexServiceTier::Fast) => Some(&mut model_usage.recorded_fast_usage),
             Some(CodexServiceTier::Flex) => Some(&mut model_usage.recorded_flex_usage),
+            Some(CodexServiceTier::Ultrafast) => Some(&mut model_usage.recorded_ultrafast_usage),
             None => None,
         };
         if let Some(recorded_usage) = recorded_usage {
@@ -562,6 +566,7 @@ fn merge_recorded_codex_usage(
         CodexServiceTier::Standard => &mut model_usage.recorded_standard_usage,
         CodexServiceTier::Fast => &mut model_usage.recorded_fast_usage,
         CodexServiceTier::Flex => &mut model_usage.recorded_flex_usage,
+        CodexServiceTier::Ultrafast => &mut model_usage.recorded_ultrafast_usage,
     };
     merge_codex_usage_bucket(recorded_usage, usage);
 
@@ -574,6 +579,7 @@ fn merge_recorded_codex_usage(
             CodexServiceTier::Standard => &mut timestamped_usage.recorded_standard_usage,
             CodexServiceTier::Fast => &mut timestamped_usage.recorded_fast_usage,
             CodexServiceTier::Flex => &mut timestamped_usage.recorded_flex_usage,
+            CodexServiceTier::Ultrafast => &mut timestamped_usage.recorded_ultrafast_usage,
         };
         merge_codex_usage_bucket(recorded_usage, usage);
     }
@@ -826,6 +832,10 @@ fn merge_codex_model_usage(target: &mut crate::CodexModelUsage, source: crate::C
     );
     merge_codex_usage_bucket(&mut target.recorded_fast_usage, source.recorded_fast_usage);
     merge_codex_usage_bucket(&mut target.recorded_flex_usage, source.recorded_flex_usage);
+    merge_codex_usage_bucket(
+        &mut target.recorded_ultrafast_usage,
+        source.recorded_ultrafast_usage,
+    );
     for (timestamp, usage) in source.timestamped_usage {
         let target_usage = target.timestamped_usage.entry(timestamp).or_default();
         merge_codex_usage_bucket(&mut target_usage.usage, usage.usage);
@@ -841,6 +851,10 @@ fn merge_codex_model_usage(target: &mut crate::CodexModelUsage, source: crate::C
             &mut target_usage.recorded_flex_usage,
             usage.recorded_flex_usage,
         );
+        merge_codex_usage_bucket(
+            &mut target_usage.recorded_ultrafast_usage,
+            usage.recorded_ultrafast_usage,
+        );
     }
     target.is_fallback |= source.is_fallback;
 }
 
@@ -8,7 +8,11 @@ use crate::{
     load_codex_events_from_directory,
     parser::visit_codex_session_file,
     report::report_from_groups,
-    types::CodexRawUsage,
+    types::{
+        CodexRawUsage,
+        CodexServiceTier::{Fast, Flex, Standard, Ultrafast},
+        CodexTokenUsageEvent,
+    },
 };
 
 fn compaction_log(timestamp: &str, model: &str, input_tokens: u64) -> String {
@@ -232,21 +236,58 @@ fn direct_reports_merge_recorded_tiers_of_duplicate_compactions() {
     let fixture = fs_fixture!({
         "first.jsonl": compaction_log("2026-09-01T00:00:01Z", "gpt-5", 300),
     });
-    let first = load_codex_events_from_directory(fixture.root(), true)
+    let loaded = load_codex_events_from_directory(fixture.root(), true)
         .unwrap()
         .remove(0);
-    let mut duplicate = first.clone();
-    duplicate.session_id = "copied-session".into();
-    duplicate.service_tier = Some(crate::CodexServiceTier::Fast);
-    let groups =
-        aggregate_events(&[first, duplicate], AgentReportKind::Session, Some("UTC")).unwrap();
-    assert_eq!(groups.len(), 1);
-    assert_eq!(
-        groups["first"].models["gpt-5"]
-            .recorded_fast_usage
-            .input_tokens,
-        300
-    );
+    for (first_tier, copy_tier, merged_tier) in [
+        (None, Fast, Fast),
+        (None, Ultrafast, Ultrafast),
+        (Some(Fast), Ultrafast, Ultrafast),
+        (Some(Ultrafast), Flex, Ultrafast),
+        (Some(Ultrafast), Standard, Standard),
+        (Some(Standard), Ultrafast, Standard),
+    ] {
+        let first = CodexTokenUsageEvent {
+            service_tier: first_tier,
+            ..loaded.clone()
+        };
+        let duplicate = CodexTokenUsageEvent {
+            session_id: "copied-session".into(),
+            service_tier: Some(copy_tier),
+            ..loaded.clone()
+        };
+        let groups =
+            aggregate_events(&[first, duplicate], AgentReportKind::Session, Some("UTC")).unwrap();
+        assert_eq!(groups.len(), 1);
+        let usage = &groups["first"].models["gpt-5"];
+        let recorded = [
+            (Standard, usage.recorded_standard_usage),
+            (Fast, usage.recorded_fast_usage),
+            (Flex, usage.recorded_flex_usage),
+            (Ultrafast, usage.recorded_ultrafast_usage),
+        ];
+        let input_tokens = |tier| {
+            recorded
+                .iter()
+                .filter(|(recorded_tier, _)| *recorded_tier == tier)
+                .map(|(_, bucket)| bucket.input_tokens)
+                .sum::<u64>()
+        };
+        assert_eq!(
+            input_tokens(merged_tier),
+            300,
+            "{first_tier:?} + {copy_tier:?}"
+        );
+        assert_eq!(
+            recorded
+                .iter()
+                .map(|(_, bucket)| bucket.input_tokens)
+                .sum::<u64>(),
+            300,
+            "{first_tier:?} + {copy_tier:?}"
+        );
+        assert_eq!(usage.input_tokens, 300);
+    }
 }
 
 #[test]
Original file line number	Diff line number	Diff line change
`@@ -88,6 +88,7 @@ let`
`88`	`88`	`lib.optionals (lib.elem "ccusage-core" names) [`
`89`	`89`	`(rustRoot + /crates/ccusage-core/src/fast-multiplier-overrides.json)`
`90`	`90`	`(rustRoot + /crates/ccusage-core/src/flex-multiplier-overrides.json)`
	`91`	`+ (rustRoot + /crates/ccusage-core/src/ultrafast-multiplier-overrides.json)`
`91`	`92`	`]`
`92`	`93`	`++ lib.optionals (lib.elem "ccusage-adapter-codex" names) [`
`93`	`94`	`(rustRoot + /adapters/codex/src/codex-auto-review-fallbacks.json)`