Fast Path and Parallel Prefetch: The Secret to Sub‑Second CLI Startup

01 An Unexpected Number

The distributed dist/cli.js contains the beta header "fast-mode-2026-02-01". When this header is sent, the server activates a special execution path that adds speed: "fast" to the request body, delivering an order‑of‑magnitude speed boost on Opus 4.6.

02 The Problem to Solve

CLI perceived speed equals startup latency plus first‑response latency. Node.js process start‑up already costs a few hundred milliseconds, and six serial steps (MDM config read, macOS Keychain query, OAuth token init, MCP config load, system prompt build, first API request) can add another 600 ms if each takes ~100 ms.

03 Locating the Code

The relevant source files are src/main.tsx (parallel prefetch) and src/query.ts (Fast Mode request construction). The entry point in the built artifact is the async function ek9(), compiled from main.tsx.

04 Core Implementation Walk‑through

4.1 Parallel Prefetch: Two Promises, One Await

In the preAction hook the CLI runs:

await Promise.all([GU8(), iT8()])

GU8()

lazily loads MDM enterprise configuration and caches it; iT8() launches two child processes to query the macOS Keychain for the logged‑in and default profiles, then caches the results. Both functions are fire‑and‑forget during module initialization, stored in module‑level variables, and only awaited later.

4.2 Fast Mode: speed: "fast" Cost and Conditions

Fast Mode is gated by a series of checks:

function h1() { // global switch
  if (!C7()) return false;
  return dY6() === null;
}
function dY6() { // feature flag and platform checks
  if (!C7()) return "Fast mode is not available";
  const reason = O8("tengu_penguins_off", null);
  if (reason !== null) return reason;
  if ($K() !== "firstParty")
    return "Fast mode is not available on Bedrock, Vertex, or Foundry";
  if (Zv.status === "disabled") {
    const K = q_() !== null ? "oauth" : "api-key";
    return DU4(Zv.reason, K);
  }
  return null; // all checks passed
}
function dA(model) { // model restriction
  if (!C7()) return false;
  const K = model ?? iP();
  return q4(K).toLowerCase().includes("opus-4-6");
}
function Vgq(model) { // session‑level opt‑in
  if (!C7() || !h1() || !dA(model)) return false;
  const K = fK();
  if (K.fastModePerSessionOptIn) return false;
  return K.fastMode === true;
}

When all conditions succeed, the request builder injects speed: "fast" and adds the beta header to the outgoing request.

4.3 Fast Mode Degradation and Cooldown

If the server rejects a fast request, the client enters a cooldown state instead of retrying indefinitely:

function SfK(resetAt, reason) {
  if (!C7()) return;
  cY6 = { status: "cooldown", resetAt, reason };
  Rgq = false;
  const duration = resetAt - Date.now();
  R(`Fast mode cooldown triggered (${reason}), duration ${Math.round(duration/1000)}s`);
  RfK.emit(resetAt, reason);
}
function Lgq() {
  if (cY6.status === "cooldown" && Date.now() >= cY6.resetAt) {
    if (C7() && !Rgq) {
      R("Fast mode cooldown expired, re‑enabling fast mode");
      Rgq = true;
      VfK.emit();
    }
    cY6 = { status: "active" };
  }
  return cY6;
}

The cooldown duration is supplied by the server, allowing Anthropic to adjust rate‑limiting without client updates.

05 Design Insights

Insight 1: Fire‑and‑Forget Is Core to TTI Optimization

Both lT8() and La7() start their work during module load, store the resulting promises, and later await them. This pattern can be reused for DNS pre‑resolution, DB connection pooling, or config pre‑loading.

Insight 2: Promise.all Provides Concurrency and a Synchronisation Point

Using await Promise.all([...]) in the preAction hook ensures that all prefetches finish before command execution while still running concurrently.

Insight 3: Layered Gatekeeping Improves Maintainability

Fast Mode’s seven independent checks return string | null, making it easy to add new conditions and to log exactly which gate blocked the feature.

Insight 4: Cooldown Is Friendlier Than Hard Errors

When the server throttles fast requests, the client degrades gracefully, enters a timed cooldown, and automatically recovers, providing a smoother user experience.

06 Critical Perspective

Fast Mode Tied to a Specific Model

The dA() function hard‑codes the check for opus-4-6. Future model releases would require code changes, a potential technical debt.

Assumptions Behind Parallel Prefetch

The design assumes that Keychain queries finish before command parsing completes. On very slow machines this may not hold, causing the prefetch to become effectively serial. Adding a timeout could mitigate this, albeit at the risk of auth failures.

Platform‑Specificity

MDM and Keychain prefetches are macOS‑only; on Linux only the MDM line runs, limiting the achievable speedup.

07 Practical Recommendations

Scenario 1: Prefetch in a Node.js CLI

// Trigger pre‑warming at module load (non‑async context)
const prefetchPromises = [];
if (process.platform === "darwin") {
  prefetchPromises.push(prefetchKeychain());
}
prefetchPromises.push(loadConfig());
// Wait for all prefetches before command execution
program.hook("preAction", async () => {
  await Promise.all(prefetchPromises);
});

Scenario 2: Chainable Nullable Returns for Feature Gating

type FeatureBlockReason = string | null;
function canUsePremiumFeature(userId: string): FeatureBlockReason {
  if (!isGlobalEnabled()) return "Feature disabled globally";
  if (!isUserTierEligible(userId)) return "Requires premium tier";
  if (isInCooldown(userId)) return "In cooldown period";
  return null; // feature usable
}
const blockReason = canUsePremiumFeature(userId);
if (blockReason) {
  showToUser(blockReason);
  return;
}

Scenario 3: Automatic Recovery from Degraded Mode

let degradedState = { active: false, resetAt: 0 };
function enterDegradedMode(durationMs) {
  degradedState = { active: true, resetAt: Date.now() + durationMs };
  scheduleRecovery(durationMs);
}
function checkAndRecoverFromDegradedMode() {
  if (degradedState.active && Date.now() >= degradedState.resetAt) {
    degradedState = { active: false, resetAt: 0 };
    emitRecoveryEvent();
  }
  return degradedState;
}

08 Diagrams

09 Summary

1️⃣ Parallel prefetch is the core lever for reducing time‑to‑interactive. By fire‑and‑forget loading of MDM and Keychain and awaiting them with Promise.all, command‑parsing time overlaps I/O latency.

2️⃣ The speed: "fast" field, together with the beta header fast-mode-2026-02-01, activates a server‑side fast execution path exclusive to the claude‑opus‑4‑6 model.

3️⃣ Seven independent gate checks guarantee that Fast Mode is only enabled when safe, and each returns a clear reason for rejection.

4️⃣ The cooldown mechanism turns rate‑limiting into graceful degradation with automatic recovery and UI notification.

5️⃣ Limitations include model‑specific hard‑coding, optimistic prefetch assumptions on slow devices, and macOS‑only MDM/Keychain paths.