diff --git a/README.md b/README.md
index afe89cd..d0e64d9 100644
--- a/README.md
+++ b/README.md
@@ -63,19 +63,22 @@ metadata and are never recursively removed or rewritten by the CLI.
 
 ## Run idempotency
 
-Use an explicit idempotency key when a run may need to be repeated without another charge:
+The CLI generates a fresh random idempotency key for every logical invocation. Use an explicit
+key when a run may need to be resumed manually without another charge:
 
 ```sh
 anyapi run reddit.search --input '{"query":"anyapi"}' --idempotency-key k1
 ```
 
-Repeating the same request with the same key returns the original result without another charge once the gateway supports idempotency. Keys must be 1 to 255 visible ASCII characters. The CLI does not generate a key unless you explicitly opt in with `auto`:
+Repeating the same request with the same key returns the original result without another charge.
+Keys must be 1 to 255 visible ASCII characters. You can explicitly request another random key with
+`auto`:
 
 ```sh
 anyapi run reddit.search --input '{"query":"anyapi"}' --idempotency-key auto
 ```
 
-`auto` derives a deterministic key from the SKU, canonical JSON input, and current UTC date. Equivalent JSON formatting and property order produce the same key and request body during that day. Use `auto` to protect against accidental same-day reruns, but omit it when repeated runs are intentional.
+`auto` creates a random key for that invocation. It does not deduplicate a separate CLI command.
 
 If a key is already running, the CLI asks you to retry shortly with the same key. If a key was used with a different SKU or input, the CLI asks you to use a new key or retry the original request.
 
diff --git a/__tests__/run.test.ts b/__tests__/run.test.ts
index 159074d..a90cec2 100644
--- a/__tests__/run.test.ts
+++ b/__tests__/run.test.ts
@@ -1,40 +1,48 @@
-import { join } from 'node:path';
-import { PassThrough } from 'node:stream';
-import { describe, expect, it } from 'vitest';
-import { AnyApiClient } from '../src/api.js';
-import { runCommand } from '../src/commands.js';
-import { ApiError } from '../src/errors.js';
+import { join } from "node:path";
+import { PassThrough } from "node:stream";
+import { Command } from "commander";
+import { describe, expect, it } from "vitest";
+import { AnyApiClient } from "../src/api.js";
+import { runCommand } from "../src/commands.js";
+import { ApiError } from "../src/errors.js";
 import {
   buildRunOutputPath,
   formatIdempotencyError,
   formatTrialCapMessage,
   isTrialCapReached,
+  normalizeRunCLIOptions,
   parseRunInput,
   prepareRunIdempotency,
-} from '../src/run.js';
-import type { CommandContext } from '../src/io.js';
-import type { FetchLike } from '../src/types.js';
+} from "../src/run.js";
+import type { CommandContext } from "../src/io.js";
+import type { FetchLike } from "../src/types.js";
 
-describe('run idempotency', () => {
-  it('preserves customer output fields without recursive rewriting', async () => {
+describe("run idempotency", () => {
+  it("maps Commander negated --no-wait into the transport option", () => {
+    const command = new Command().exitOverride().option("--no-wait");
+    command.parse(["node", "test", "--no-wait"]);
+    expect(normalizeRunCLIOptions(command.opts()).noWait).toBe(true);
+  });
+
+  it("preserves customer output fields without recursive rewriting", async () => {
     const responseBody = {
       output: {
         found: true,
         data: {
           creditScore: 812,
-          provider: 'source named by the customer API',
-          providers: ['first source', 'second source'],
-          nested: { provider: { name: 'structured provider value' } },
+          provider: "source named by the customer API",
+          providers: ["first source", "second source"],
+          nested: { provider: { name: "structured provider value" } },
         },
       },
-      provider: 'AnyAPI',
+      provider: "AnyAPI",
       costUsd: 0.01,
       items: 1,
     };
     const ctx = commandContext(async () => Response.json(responseBody));
 
-    await runCommand(ctx, { apiKey: 'aa_live_test' }, 'finance.profile', {
-      input: '{}',
+    await runCommand(ctx, { apiKey: "aa_live_test" }, "finance.profile", {
+      input: "{}",
       json: true,
     });
 
@@ -42,83 +50,127 @@ describe('run idempotency', () => {
     expect(JSON.parse(stdout)).toEqual(responseBody);
   });
 
-  it('preserves balance response fields without recursive rewriting', async () => {
+  it("preserves balance response fields without recursive rewriting", async () => {
     const responseBody = {
       balanceUsd: 1.25,
       creditScore: 812,
-      provider: 'account-data-source',
-      providers: ['account-data-source'],
+      provider: "account-data-source",
+      providers: ["account-data-source"],
     };
     const client = new AnyApiClient({
-      apiKey: 'aa_live_test',
+      apiKey: "aa_live_test",
       fetchImpl: async () => Response.json(responseBody),
-      restBaseUrl: 'https://example.test/v1',
+      restBaseUrl: "https://example.test/v1",
     });
 
     await expect(client.balance()).resolves.toEqual(responseBody);
   });
 
-  it('passes the command flag through to the idempotency key header', async () => {
+  it("passes the command flag through to the idempotency key header", async () => {
     let requestInit: RequestInit | undefined;
     const fetchImpl: FetchLike = async (_input, init) => {
       requestInit = init;
-      return Response.json({ output: {}, provider: 'AnyAPI', costUsd: 0.01, items: 1 });
+      return Response.json({
+        output: {},
+        provider: "AnyAPI",
+        costUsd: 0.01,
+        items: 1,
+      });
     };
 
-    await runCommand(commandContext(fetchImpl), { apiKey: 'aa_live_test' }, 'reddit.search', {
-      input: '{"query":"anyapi"}',
-      idempotencyKey: 'k1',
-      json: true,
-    });
+    await runCommand(
+      commandContext(fetchImpl),
+      { apiKey: "aa_live_test" },
+      "reddit.search",
+      {
+        input: '{"query":"anyapi"}',
+        idempotencyKey: "k1",
+        json: true,
+      },
+    );
 
-    expect(new Headers(requestInit?.headers).get('Idempotency-Key')).toBe('k1');
+    expect(new Headers(requestInit?.headers).get("Idempotency-Key")).toBe("k1");
   });
 
-  it('omits the idempotency key header when the flag is absent', async () => {
+  it("generates a fresh idempotency key when the flag is absent", async () => {
     let requestInit: RequestInit | undefined;
     const fetchImpl: FetchLike = async (_input, init) => {
       requestInit = init;
-      return Response.json({ output: {}, provider: 'AnyAPI', costUsd: 0.01, items: 1 });
+      return Response.json({
+        output: {},
+        provider: "AnyAPI",
+        costUsd: 0.01,
+        items: 1,
+      });
     };
 
-    await runCommand(commandContext(fetchImpl), { apiKey: 'aa_live_test' }, 'reddit.search', {
-      input: '{"query":"anyapi"}',
-      json: true,
-    });
+    await runCommand(
+      commandContext(fetchImpl),
+      { apiKey: "aa_live_test" },
+      "reddit.search",
+      {
+        input: '{"query":"anyapi"}',
+        json: true,
+      },
+    );
 
-    expect(new Headers(requestInit?.headers).has('Idempotency-Key')).toBe(false);
+    expect(new Headers(requestInit?.headers).get("Idempotency-Key")).toMatch(
+      /^anyapi-auto-/,
+    );
   });
 
-  it('derives the same auto key and request body from equivalent JSON input', async () => {
+  it("derives a fresh auto key while keeping equivalent request bodies stable", async () => {
     const firstInput = await parseRunInput({
       input: '{"query":"anyapi","filters":{"sort":"new","limit":5}}',
     });
     const secondInput = await parseRunInput({
       input: '{ "filters": { "limit": 5, "sort": "new" }, "query": "anyapi" }',
     });
-    const date = new Date('2026-07-27T12:00:00Z');
+    const date = new Date("2026-07-27T12:00:00Z");
 
-    const first = prepareRunIdempotency('reddit.search', firstInput, 'auto', date);
-    const second = prepareRunIdempotency('reddit.search', secondInput, 'auto', date);
+    const first = prepareRunIdempotency(
+      "reddit.search",
+      firstInput,
+      "auto",
+      date,
+    );
+    const second = prepareRunIdempotency(
+      "reddit.search",
+      secondInput,
+      "auto",
+      date,
+    );
 
-    expect(second.idempotencyKey).toBe(first.idempotencyKey);
+    expect(second.idempotencyKey).not.toBe(first.idempotencyKey);
     expect(JSON.stringify(second.input)).toBe(JSON.stringify(first.input));
-    expect(first.idempotencyKey).toMatch(/^anyapi-auto-[a-f0-9]{64}$/);
+    expect(first.idempotencyKey).toMatch(/^anyapi-auto-[a-f0-9-]{36}$/);
+    expect(second.idempotencyKey).toMatch(/^anyapi-auto-[a-f0-9-]{36}$/);
   });
 
-  it('rejects explicit keys outside the gateway wire format', () => {
-    expect(() => prepareRunIdempotency('reddit.search', {}, '')).toThrow('1 to 255 visible ASCII');
-    expect(() => prepareRunIdempotency('reddit.search', {}, 'contains space')).toThrow('1 to 255 visible ASCII');
-    expect(() => prepareRunIdempotency('reddit.search', {}, 'ends-with-newline\n')).toThrow('1 to 255 visible ASCII');
-    expect(() => prepareRunIdempotency('reddit.search', {}, 'x'.repeat(256))).toThrow('1 to 255 visible ASCII');
-    expect(prepareRunIdempotency('reddit.search', {}, 'x'.repeat(255)).idempotencyKey).toHaveLength(255);
+  it("rejects explicit keys outside the gateway wire format", () => {
+    expect(() => prepareRunIdempotency("reddit.search", {}, "")).toThrow(
+      "1 to 255 visible ASCII",
+    );
+    expect(() =>
+      prepareRunIdempotency("reddit.search", {}, "contains space"),
+    ).toThrow("1 to 255 visible ASCII");
+    expect(() =>
+      prepareRunIdempotency("reddit.search", {}, "ends-with-newline\n"),
+    ).toThrow("1 to 255 visible ASCII");
+    expect(() =>
+      prepareRunIdempotency("reddit.search", {}, "x".repeat(256)),
+    ).toThrow("1 to 255 visible ASCII");
+    expect(
+      prepareRunIdempotency("reddit.search", {}, "x".repeat(255))
+        .idempotencyKey,
+    ).toHaveLength(255);
   });
 });
 
 function commandContext(fetchImpl: FetchLike): CommandContext {
   return {
-    cwd: '/tmp',
-    homeDir: '/tmp',
+    cwd: "/tmp",
+    homeDir: "/tmp",
     env: {},
     stdin: new PassThrough(),
     stdout: new PassThrough(),
@@ -127,68 +179,91 @@ function commandContext(fetchImpl: FetchLike): CommandContext {
   };
 }
 
-describe('run output paths', () => {
-  it('uses sku and a file-safe ISO timestamp under .anyapi', () => {
-    const path = buildRunOutputPath('reddit.search', new Date('2026-07-05T19:20:30.456Z'), '/tmp/project');
-    expect(path).toBe(join('/tmp/project', '.anyapi', 'reddit.search-2026-07-05T19-20-30-456Z.json'));
+describe("run output paths", () => {
+  it("uses sku and a file-safe ISO timestamp under .anyapi", () => {
+    const path = buildRunOutputPath(
+      "reddit.search",
+      new Date("2026-07-05T19:20:30.456Z"),
+      "/tmp/project",
+    );
+    expect(path).toBe(
+      join(
+        "/tmp/project",
+        ".anyapi",
+        "reddit.search-2026-07-05T19-20-30-456Z.json",
+      ),
+    );
   });
 
-  it('replaces unsafe sku characters', () => {
-    const path = buildRunOutputPath('web/scrape test', new Date('2026-07-05T19:20:30.456Z'), '/tmp/project');
-    expect(path.endsWith('web_scrape_test-2026-07-05T19-20-30-456Z.json')).toBe(true);
+  it("replaces unsafe sku characters", () => {
+    const path = buildRunOutputPath(
+      "web/scrape test",
+      new Date("2026-07-05T19:20:30.456Z"),
+      "/tmp/project",
+    );
+    expect(path.endsWith("web_scrape_test-2026-07-05T19-20-30-456Z.json")).toBe(
+      true,
+    );
   });
 });
 
-describe('402 handling', () => {
-  it('detects trial cap errors and relays the server upgrade guidance', async () => {
+describe("402 handling", () => {
+  it("detects trial cap errors and relays the server upgrade guidance", async () => {
     const fetchImpl: FetchLike = async () =>
       new Response(
-        JSON.stringify({ error: 'trial_cap_reached', message: 'Trial budget used up; run anyapi connect.' }),
-        { status: 402, headers: { 'Content-Type': 'application/json' } },
+        JSON.stringify({
+          error: "trial_cap_reached",
+          message: "Trial budget used up; run anyapi connect.",
+        }),
+        { status: 402, headers: { "Content-Type": "application/json" } },
       );
     const client = new AnyApiClient({
-      apiKey: 'aa_live_test',
+      apiKey: "aa_live_test",
       fetchImpl,
-      restBaseUrl: 'https://example.test/v1',
+      restBaseUrl: "https://example.test/v1",
     });
 
     try {
-      await client.run('reddit.search', { query: 'anyapi' });
-      throw new Error('Expected run to fail');
+      await client.run("reddit.search", { query: "anyapi" });
+      throw new Error("Expected run to fail");
     } catch (error) {
       expect(error).toBeInstanceOf(ApiError);
       expect(isTrialCapReached(error)).toBe(true);
-      expect(formatTrialCapMessage(error)).toBe('Trial budget used up; run anyapi connect.');
+      expect(formatTrialCapMessage(error)).toBe(
+        "Trial budget used up; run anyapi connect.",
+      );
     }
   });
 
-  it('falls back to a connect nudge when the 402 body has no message', () => {
-    const error = new ApiError('trial_cap_reached', 402, { error: 'trial_cap_reached' });
+  it("falls back to a connect nudge when the 402 body has no message", () => {
+    const error = new ApiError("trial_cap_reached", 402, {
+      error: "trial_cap_reached",
+    });
     expect(isTrialCapReached(error)).toBe(true);
-    expect(formatTrialCapMessage(error)).toContain('anyapi connect');
+    expect(formatTrialCapMessage(error)).toContain("anyapi connect");
   });
 });
 
-describe('409 idempotency handling', () => {
-  it('explains when the key belongs to a different request using the error code', () => {
-    const error = new ApiError('Original request is still running.', 409, {
-      error: 'Original request is still running.',
-      code: 'idempotency_conflict',
+describe("409 idempotency handling", () => {
+  it("explains when the key belongs to a different request using the error code", () => {
+    const error = new ApiError("Original request is still running.", 409, {
+      error: "Original request is still running.",
+      code: "idempotency_conflict",
     });
 
     expect(formatIdempotencyError(error)).toBe(
-      'This idempotency key was already used for a different request. Use a new key, or retry with the original SKU and input.',
+      "This idempotency key was already used for a different request. Use a new key, or retry with the original SKU and input.",
     );
   });
 
-  it('explains when the original request is still running using the error code', () => {
-    const error = new ApiError('This key belongs to another request.', 409, {
-      error: 'This key belongs to another request.',
-      code: 'idempotency_in_progress',
+  it("explains when the original request is still running using the error code", () => {
+    const error = new ApiError("This key belongs to another request.", 409, {
+      error: "This key belongs to another request.",
+      code: "idempotency_in_progress",
     });
 
     expect(formatIdempotencyError(error)).toBe(
-      'The original request for this idempotency key is still running. Retry shortly with the same key.',
+      "The original request for this idempotency key is still running. Retry shortly with the same key.",
     );
   });
 });
diff --git a/package-lock.json b/package-lock.json
index 0a95453..4d13756 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "anyapi-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "anyapi-cli",
-      "version": "0.5.0",
+      "version": "0.6.0",
       "license": "MIT",
       "dependencies": {
         "commander": "^12.1.0",
diff --git a/package.json b/package.json
index fcc6379..d98188f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "anyapi-cli",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Official CLI for AnyAPI, a unified marketplace for scraping and data APIs.",
   "type": "module",
   "bin": {
diff --git a/skills/anyapi-run/SKILL.md b/skills/anyapi-run/SKILL.md
index b7504d7..eacc450 100644
--- a/skills/anyapi-run/SKILL.md
+++ b/skills/anyapi-run/SKILL.md
@@ -36,9 +36,14 @@ anyapi run reddit.search --input '{"query":"anyapi"}' --idempotency-key task-123
 ```
 
 Repeating the same request with the same key returns its original result without
-another charge. Use `--idempotency-key auto` to derive an opt-in daily key from
-the SKU and canonical JSON input. Omit the flag when repeated runs are
-intentional.
+another charge. The CLI generates a random key for every logical invocation. Pass
+an explicit `--idempotency-key` only when you need to resume that invocation yourself.
+`--idempotency-key auto` explicitly requests the same random per-invocation behavior.
+
+Provider-job APIs poll to completion by default. Use `--no-wait` to return the
+durable request ID immediately, then run `anyapi requests get <id>` or
+`anyapi requests wait <id>`. Never repeat the paid `run`; resume by request ID.
+On Ctrl-C the CLI prints the exact resume command.
 
 ## Run once, reshape forever at zero cost
 
diff --git a/src/api.ts b/src/api.ts
index 94b3e68..0262087 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -1,6 +1,6 @@
 import { CATALOG_URL, REST_BASE_URL, SIGNUP_URL } from './constants.js';
 import { readCatalogResponse, readDiscoveryApi, readSearchResponse } from './discovery.js';
-import { ApiError } from './errors.js';
+import { ApiError, CliError } from './errors.js';
 import type {
   CatalogApi,
   CatalogResponse,
@@ -9,6 +9,7 @@ import type {
   FetchLike,
   OAuthMetadata,
   RunResult,
+  RequestSnapshot,
   SearchResponse,
   SignupResponse,
   TokenResponse,
@@ -28,6 +29,8 @@ export interface SignupOptions {
 
 export interface RunOptions {
   idempotencyKey?: string;
+  noWait?: boolean;
+  onAccepted?: (snapshot: RequestSnapshot) => void;
 }
 
 export class AnyApiClient {
@@ -150,17 +153,43 @@ export class AnyApiClient {
   // run always fetches the FULL result. Response shaping (fields/max_items/summary/
   // jq) is done locally by the CLI over the saved file, so re-slicing a paid run
   // costs nothing; no shape params are sent upstream.
-  async run(sku: string, input: unknown, options: RunOptions = {}): Promise<RunResult> {
+  async run(sku: string, input: unknown, options: RunOptions = {}): Promise<RunResult | RequestSnapshot> {
     const url = new URL(`${this.restBaseUrl}/run/${encodeURIComponent(sku)}`);
-    return this.requestJson<RunResult>(url, {
+    const response = await this.requestJson<RunResult | RequestSnapshot>(url, {
       method: 'POST',
       headers: {
         ...this.authHeaders(),
         'Content-Type': 'application/json',
         ...(options.idempotencyKey ? { 'Idempotency-Key': options.idempotencyKey } : {}),
+        ...(options.noWait ? { Prefer: 'respond-async' } : {}),
       },
       body: JSON.stringify(input),
     });
+    if (!isRequestSnapshot(response)) return response;
+    options.onAccepted?.(response);
+    if (options.noWait) return response;
+    return this.waitRequest(response.requestId, response);
+  }
+
+  async getRequest(requestId: string): Promise<RequestSnapshot> {
+    return this.requestJson<RequestSnapshot>(`${this.restBaseUrl}/requests/${encodeURIComponent(requestId)}`, {
+      headers: this.authHeaders(),
+    });
+  }
+
+  async waitRequest(requestId: string, initial?: RequestSnapshot): Promise<RunResult> {
+    let snapshot = initial ?? await this.getRequest(requestId);
+    const deadline = Date.now() + 300_000;
+    while (snapshot.status === 'queued' || snapshot.status === 'running') {
+      if (Date.now() >= deadline) {
+        throw new CliError(`Request ${requestId} is still running. Resume with: anyapi requests wait ${requestId}`);
+      }
+      await delay(Math.max(1, snapshot.retryAfterSeconds ?? 2) * 1000);
+      snapshot = await this.getRequest(requestId);
+    }
+    if (snapshot.status === 'succeeded' && snapshot.result) return snapshot.result;
+    if (snapshot.resultExpired) throw new CliError(`Request ${requestId} succeeded, but its result expired.`);
+    throw new CliError(`Request ${requestId} ended with ${snapshot.error?.code ?? snapshot.status}.`);
   }
 
   async balance(): Promise<unknown> {
@@ -186,6 +215,11 @@ export class AnyApiClient {
   }
 }
 
+const delay = (milliseconds: number) => new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
+const isRequestSnapshot = (value: unknown): value is RequestSnapshot =>
+  typeof value === 'object' && value !== null && typeof (value as RequestSnapshot).requestId === 'string' &&
+  typeof (value as RequestSnapshot).status === 'string';
+
 function compactObject(input: Record<string, string | undefined>): Record<string, string> {
   return Object.fromEntries(
     Object.entries(input).filter((entry): entry is [string, string] => typeof entry[1] === 'string' && entry[1] !== ''),
diff --git a/src/commands.ts b/src/commands.ts
index 724ef9b..317ce12 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -24,7 +24,7 @@ import { resolveLastFile } from './view.js';
 import { configureMcp, detectAgents, installSkillsForAgents, printAgentDetection } from './init.js';
 import { promptYesNo, writeLine, type CommandContext } from './io.js';
 import { deviceLoginCommand, type DeviceLoginDependencies } from './login.js';
-import type { AnyApiConfig, CatalogApi, RunResult, SignupResponse } from './types.js';
+import type { AnyApiConfig, CatalogApi, RequestSnapshot, RunResult, SignupResponse } from './types.js';
 
 interface ShapeCliOptions {
   fields?: string;
@@ -106,6 +106,7 @@ export async function runCommand(
     idempotencyKey?: string;
     output?: string;
     json?: boolean;
+    noWait?: boolean;
   },
 ): Promise<void> {
   const auth = await requireApiKey(ctx, global);
@@ -114,11 +115,21 @@ export async function runCommand(
   const prepared = prepareRunIdempotency(sku, input, options.idempotencyKey);
   const shape = parseShapeRequest(options);
 
-  let result: RunResult;
+  let result: RunResult | RequestSnapshot;
+  let acceptedRequestId: string | undefined;
+  const onInterrupt = () => {
+    if (acceptedRequestId) writeLine(ctx.stderr, `Resume with: anyapi requests wait ${acceptedRequestId}`);
+    process.exit(130);
+  };
   try {
     result = stripServerHint(await client.run(sku, prepared.input, {
       idempotencyKey: prepared.idempotencyKey,
-    }));
+      noWait: options.noWait,
+      onAccepted: (snapshot) => {
+        acceptedRequestId = snapshot.requestId;
+        process.once('SIGINT', onInterrupt);
+      },
+    }) as RunResult);
   } catch (error) {
     const idempotencyMessage = formatIdempotencyError(error);
     if (idempotencyMessage) {
@@ -129,6 +140,15 @@ export async function runCommand(
       throw new CliError('trial_cap_reached');
     }
     throw error;
+  } finally {
+    process.removeListener('SIGINT', onInterrupt);
+  }
+
+  if (isRequestSnapshot(result)) {
+    const rendered = JSON.stringify(result, null, options.json ? 0 : 2);
+    writeLine(ctx.stdout, rendered);
+    if (!options.json) writeLine(ctx.stdout, `Resume with: anyapi requests wait ${result.requestId}`);
+    return;
   }
 
   const shaped = hasShapeFlags(shape);
@@ -159,6 +179,21 @@ export async function runCommand(
   }
 }
 
+export async function getRequestCommand(ctx: CommandContext, global: GlobalOptions, requestId: string): Promise<void> {
+  const auth = await requireApiKey(ctx, global);
+  const client = new AnyApiClient({ apiKey: auth.apiKey, fetchImpl: ctx.fetchImpl });
+  writeLine(ctx.stdout, JSON.stringify(await client.getRequest(requestId), null, 2));
+}
+
+export async function waitRequestCommand(ctx: CommandContext, global: GlobalOptions, requestId: string): Promise<void> {
+  const auth = await requireApiKey(ctx, global);
+  const client = new AnyApiClient({ apiKey: auth.apiKey, fetchImpl: ctx.fetchImpl });
+  writeLine(ctx.stdout, JSON.stringify(await client.waitRequest(requestId), null, 2));
+}
+
+const isRequestSnapshot = (value: RunResult | RequestSnapshot): value is RequestSnapshot =>
+  typeof value.requestId === 'string' && typeof value.status === 'string';
+
 export async function viewCommand(
   ctx: CommandContext,
   path: string | undefined,
diff --git a/src/index.ts b/src/index.ts
index bce73f0..fd3c40a 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
+import { Command } from "commander";
 import {
   balanceCommand,
   describeCommand,
   initCommand,
+  getRequestCommand,
   listCommand,
   loginCommand,
   runCommand,
@@ -11,101 +12,174 @@ import {
   setupSkillsCommand,
   signupCommand,
   viewCommand,
+  waitRequestCommand,
   type GlobalOptions,
-} from './commands.js';
-import { connectCommand } from './connect.js';
-import { CliError } from './errors.js';
-import { defaultContext } from './io.js';
+} from "./commands.js";
+import { connectCommand } from "./connect.js";
+import { CliError } from "./errors.js";
+import { defaultContext } from "./io.js";
+import { normalizeRunCLIOptions } from "./run.js";
 
 const program = new Command();
 const ctx = defaultContext();
 
 program
-  .name('anyapi')
-  .description('Official CLI for AnyAPI.')
-  .option('--api-key <apiKey>', 'AnyAPI API key. Overrides ANYAPI_API_KEY and local config.')
-  .version('0.5.0');
+  .name("anyapi")
+  .description("Official CLI for AnyAPI.")
+  .option(
+    "--api-key <apiKey>",
+    "AnyAPI API key. Overrides ANYAPI_API_KEY and local config.",
+  )
+  .version("0.5.0");
 
 program
-  .command('signup')
-  .description('Mint a free AnyAPI trial key and save it locally.')
-  .option('--label <label>', 'Label for the generated key.')
-  .option('--show-key', 'Print the generated secret key once.')
+  .command("signup")
+  .description("Mint a free AnyAPI trial key and save it locally.")
+  .option("--label <label>", "Label for the generated key.")
+  .option("--show-key", "Print the generated secret key once.")
   .action((options) => run(() => signupCommand(ctx, options)));
 
 program
-  .command('login')
-  .description('Sign in with cross-device OAuth, or store an existing key with --api-key.')
-  .option('--api-key <apiKey>', 'Store an existing AnyAPI API key instead of starting OAuth.')
-  .action((options) => run(() => loginCommand(ctx, { apiKey: options.apiKey ?? globalOptions().apiKey })));
+  .command("login")
+  .description(
+    "Sign in with cross-device OAuth, or store an existing key with --api-key.",
+  )
+  .option(
+    "--api-key <apiKey>",
+    "Store an existing AnyAPI API key instead of starting OAuth.",
+  )
+  .action((options) =>
+    run(() =>
+      loginCommand(ctx, { apiKey: options.apiKey ?? globalOptions().apiKey }),
+    ),
+  );
 
 program
-  .command('search')
-  .description('Search the public AnyAPI catalog.')
-  .argument('<query>', 'Search query.')
+  .command("search")
+  .description("Search the public AnyAPI catalog.")
+  .argument("<query>", "Search query.")
   .action((query) => run(() => searchCommand(ctx, query)));
 
 program
-  .command('list')
-  .description('List APIs in the public AnyAPI catalog.')
-  .option('--category <category>', 'Filter by category.')
+  .command("list")
+  .description("List APIs in the public AnyAPI catalog.")
+  .option("--category <category>", "Filter by category.")
   .action((options) => run(() => listCommand(ctx, options)));
 
 program
-  .command('describe')
-  .description('Print one API definition with schemas and USD pricing.')
-  .argument('<sku>', 'API SKU.')
+  .command("describe")
+  .description("Print one API definition with schemas and USD pricing.")
+  .argument("<sku>", "API SKU.")
   .action((sku) => run(() => describeCommand(ctx, globalOptions(), sku)));
 
 program
-  .command('run')
-  .description('Run an AnyAPI SKU. Always saves the full result; shape flags trim only the stdout view.')
-  .argument('<sku>', 'API SKU.')
-  .option('--input <json>', 'JSON input body.')
-  .option('-i, --input-file <file>', 'Read JSON input from a file.')
-  .option('--idempotency-key <key>', 'Deduplicate this run with an explicit key, or use "auto" for a daily input-derived key.')
-  .option('--jq <expr>', 'Local jq expression over the result output ({found, data}). Applied to stdout only.')
-  .option('--fields <fields>', 'Local: comma-separated fields to keep in each result item (stdout only).')
-  .option('--max-items <count>', 'Local: cap result items shown on stdout (the saved file keeps all).')
-  .option('--summary', 'Local: print a structural summary of the result on stdout.')
-  .option('-o, --output <path>', 'Output path for the full result JSON.')
-  .option('--json', 'Print the (shaped) JSON to stdout instead of writing a file.')
-  .action((sku, options) => run(() => runCommand(ctx, globalOptions(), sku, options)));
+  .command("run")
+  .description(
+    "Run an AnyAPI SKU. Always saves the full result; shape flags trim only the stdout view.",
+  )
+  .argument("<sku>", "API SKU.")
+  .option("--input <json>", "JSON input body.")
+  .option("-i, --input-file <file>", "Read JSON input from a file.")
+  .option(
+    "--idempotency-key <key>",
+    'Deduplicate this run with an explicit key, or use "auto" for a random per-invocation key.',
+  )
+  .option(
+    "--no-wait",
+    "Return a durable request ID immediately instead of polling for completion.",
+  )
+  .option(
+    "--jq <expr>",
+    "Local jq expression over the result output ({found, data}). Applied to stdout only.",
+  )
+  .option(
+    "--fields <fields>",
+    "Local: comma-separated fields to keep in each result item (stdout only).",
+  )
+  .option(
+    "--max-items <count>",
+    "Local: cap result items shown on stdout (the saved file keeps all).",
+  )
+  .option(
+    "--summary",
+    "Local: print a structural summary of the result on stdout.",
+  )
+  .option("-o, --output <path>", "Output path for the full result JSON.")
+  .option(
+    "--json",
+    "Print the (shaped) JSON to stdout instead of writing a file.",
+  )
+  .action((sku, options) =>
+    run(() =>
+      runCommand(ctx, globalOptions(), sku, normalizeRunCLIOptions(options)),
+    ),
+  );
+
+const requests = program
+  .command("requests")
+  .description("Inspect and resume durable requests.");
+requests
+  .command("get")
+  .argument("<requestId>")
+  .action((id) => run(() => getRequestCommand(ctx, globalOptions(), id)));
+requests
+  .command("wait")
+  .argument("<requestId>")
+  .action((id) => run(() => waitRequestCommand(ctx, globalOptions(), id)));
 
 program
-  .command('view')
-  .description('Re-shape a saved run file locally. Zero network, zero cost.')
-  .argument('[path]', 'Path to a saved run file. Omit to use the newest saved run.')
-  .option('--last [sku]', 'Use the newest saved run (optionally for a specific SKU).')
-  .option('--jq <expr>', 'Local jq expression over the result output ({found, data}).')
-  .option('--fields <fields>', 'Comma-separated fields to keep in each result item.')
-  .option('--max-items <count>', 'Cap the number of result items shown.')
-  .option('--summary', 'Print a structural summary of the result.')
-  .option('--json', 'Print compact JSON instead of pretty JSON.')
+  .command("view")
+  .description("Re-shape a saved run file locally. Zero network, zero cost.")
+  .argument(
+    "[path]",
+    "Path to a saved run file. Omit to use the newest saved run.",
+  )
+  .option(
+    "--last [sku]",
+    "Use the newest saved run (optionally for a specific SKU).",
+  )
+  .option(
+    "--jq <expr>",
+    "Local jq expression over the result output ({found, data}).",
+  )
+  .option(
+    "--fields <fields>",
+    "Comma-separated fields to keep in each result item.",
+  )
+  .option("--max-items <count>", "Cap the number of result items shown.")
+  .option("--summary", "Print a structural summary of the result.")
+  .option("--json", "Print compact JSON instead of pretty JSON.")
   .action((path, options) => run(() => viewCommand(ctx, path, options)));
 
 program
-  .command('balance')
-  .description('Print the remaining USD balance.')
+  .command("balance")
+  .description("Print the remaining USD balance.")
   .action(() => run(() => balanceCommand(ctx, globalOptions())));
 
 program
-  .command('connect')
-  .description('Connect an AnyAPI wallet via a one-URL OAuth approval (loopback callback).')
+  .command("connect")
+  .description(
+    "Connect an AnyAPI wallet via a one-URL OAuth approval (loopback callback).",
+  )
   .action(() => run(() => connectCommand(ctx)));
 
 program
-  .command('init')
-  .description('Mint a free trial key if none exists, install bundled skills, and show or apply MCP setup.')
-  .option('--all', 'Target all supported agents, even if not detected.')
-  .option('--yes', 'Create missing config and apply supported MCP patches without prompting.')
+  .command("init")
+  .description(
+    "Mint a free trial key if none exists, install bundled skills, and show or apply MCP setup.",
+  )
+  .option("--all", "Target all supported agents, even if not detected.")
+  .option(
+    "--yes",
+    "Create missing config and apply supported MCP patches without prompting.",
+  )
   .action((options) => run(() => initCommand(ctx, globalOptions(), options)));
 
-const setup = program.command('setup').description('Setup helpers.');
+const setup = program.command("setup").description("Setup helpers.");
 setup
-  .command('skills')
-  .description('Install bundled skills only.')
-  .option('--all', 'Target all supported agents, even if not detected.')
+  .command("skills")
+  .description("Install bundled skills only.")
+  .option("--all", "Target all supported agents, even if not detected.")
   .action((options) => run(() => setupSkillsCommand(ctx, options)));
 
 await program.parseAsync(process.argv);
@@ -119,7 +193,7 @@ async function run(action: () => Promise<void>): Promise<void> {
     await action();
   } catch (error) {
     if (error instanceof CliError) {
-      if (error.message !== 'trial_cap_reached') {
+      if (error.message !== "trial_cap_reached") {
         ctx.stderr.write(`${error.message}\n`);
       }
       process.exitCode = error.exitCode;
diff --git a/src/run.ts b/src/run.ts
index d2c3cfd..a72af7e 100644
--- a/src/run.ts
+++ b/src/run.ts
@@ -1,67 +1,97 @@
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
-import { ApiError, CliError } from './errors.js';
-import { formatUsd } from './format.js';
-import type { RunResult } from './types.js';
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { ApiError, CliError } from "./errors.js";
+import { formatUsd } from "./format.js";
+import type { RunResult } from "./types.js";
 
 export interface ParseInputOptions {
   input?: string;
   inputFile?: string;
 }
 
-export async function parseRunInput(options: ParseInputOptions): Promise<unknown> {
+export function normalizeRunCLIOptions<
+  T extends { wait?: boolean; noWait?: boolean },
+>(options: T): T & { noWait: boolean } {
+  return {
+    ...options,
+    noWait: options.noWait === true || options.wait === false,
+  };
+}
+
+export async function parseRunInput(
+  options: ParseInputOptions,
+): Promise<unknown> {
   if (options.input && options.inputFile) {
-    throw new CliError('Use either --input or --input-file, not both.');
+    throw new CliError("Use either --input or --input-file, not both.");
   }
   if (options.inputFile) {
-    return parseJson(await readFile(options.inputFile, 'utf8'), options.inputFile);
+    return parseJson(
+      await readFile(options.inputFile, "utf8"),
+      options.inputFile,
+    );
   }
   if (options.input) {
-    return parseJson(options.input, '--input');
+    return parseJson(options.input, "--input");
   }
   return {};
 }
 
 export function prepareRunIdempotency(
-  sku: string,
+  _sku: string,
   input: unknown,
   option: string | undefined,
-  date = new Date(),
+  _date = new Date(),
 ): { input: unknown; idempotencyKey?: string } {
-  if (option === undefined) {
-    return { input };
-  }
-  if (option === 'auto') {
+  if (option === undefined || option === "auto") {
     const canonicalInput = canonicalizeJson(input);
-    const dayBucket = date.toISOString().slice(0, 10);
-    const digest = createHash('sha256')
-      .update(JSON.stringify([sku, canonicalInput, dayBucket]))
-      .digest('hex');
-    return { input: canonicalInput, idempotencyKey: `anyapi-auto-${digest}` };
-  }
-  if (option.length === 0 || Buffer.byteLength(option, 'utf8') > 255 || /[^\x21-\x7e]/.test(option)) {
-    throw new CliError('--idempotency-key must be 1 to 255 visible ASCII characters.');
+    return {
+      input: canonicalInput,
+      idempotencyKey: `anyapi-auto-${randomUUID()}`,
+    };
+  }
+  if (
+    option.length === 0 ||
+    Buffer.byteLength(option, "utf8") > 255 ||
+    /[^\x21-\x7e]/.test(option)
+  ) {
+    throw new CliError(
+      "--idempotency-key must be 1 to 255 visible ASCII characters.",
+    );
   }
   return { input, idempotencyKey: option };
 }
 
-export function buildRunOutputPath(sku: string, date = new Date(), cwd = process.cwd()): string {
-  const safeSku = sku.replace(/[^a-zA-Z0-9._-]/g, '_');
-  const timestamp = date.toISOString().replace(/[:.]/g, '-');
-  return join(cwd, '.anyapi', `${safeSku}-${timestamp}.json`);
+export function buildRunOutputPath(
+  sku: string,
+  date = new Date(),
+  cwd = process.cwd(),
+): string {
+  const safeSku = sku.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const timestamp = date.toISOString().replace(/[:.]/g, "-");
+  return join(cwd, ".anyapi", `${safeSku}-${timestamp}.json`);
 }
 
-export async function writeRunOutput(result: RunResult, outputPath: string): Promise<void> {
+export async function writeRunOutput(
+  result: RunResult,
+  outputPath: string,
+): Promise<void> {
   await mkdir(dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+  await writeFile(outputPath, `${JSON.stringify(result, null, 2)}\n`, "utf8");
 }
 
-export function summarizeRun(result: RunResult, outputPath: string, cwd = process.cwd()): string {
+export function summarizeRun(
+  result: RunResult,
+  outputPath: string,
+  cwd = process.cwd(),
+): string {
   const pathText = relative(cwd, outputPath) || outputPath;
   const cost = formatUsd(result.costUsd);
-  const items = typeof result.items === 'number' ? String(result.items) : 'unknown';
-  return [`Wrote ${pathText}`, `costUsd: ${cost}`, `items: ${items}`].join('\n');
+  const items =
+    typeof result.items === "number" ? String(result.items) : "unknown";
+  return [`Wrote ${pathText}`, `costUsd: ${cost}`, `items: ${items}`].join(
+    "\n",
+  );
 }
 
 // stripServerHint removes the server's `hint` field from a run envelope. The hint
@@ -69,7 +99,7 @@ export function summarizeRun(result: RunResult, outputPath: string, cwd = proces
 // shaping over the saved file is free), so it is dropped from both the saved file
 // and stdout.
 export function stripServerHint(result: RunResult): RunResult {
-  if (!('hint' in result)) {
+  if (!("hint" in result)) {
     return result;
   }
   const { hint, ...rest } = result as RunResult & { hint?: unknown };
@@ -82,7 +112,10 @@ const hintThresholdBytes = 8 * 1024;
 
 // localRereadHint returns a nudge to re-slice the saved file for free with
 // `anyapi view`, but only for a large result saved without shape flags.
-export function localRereadHint(result: RunResult, sku: string): string | undefined {
+export function localRereadHint(
+  result: RunResult,
+  sku: string,
+): string | undefined {
   if (Buffer.byteLength(JSON.stringify(result)) < hintThresholdBytes) {
     return undefined;
   }
@@ -100,7 +133,7 @@ export function isTrialCapReached(error: unknown): boolean {
     return false;
   }
   const keys = [error.body.error, error.body.key, error.body.code];
-  return keys.some((value) => value === 'trial_cap_reached');
+  return keys.some((value) => value === "trial_cap_reached");
 }
 
 // formatTrialCapMessage relays the server's upgrade guidance (which names
@@ -112,27 +145,36 @@ export function formatTrialCapMessage(error: unknown): string {
     return serverMessage;
   }
   return [
-    'This trial key has reached its spend cap. No charge was made for the blocked call.',
-    'Upgrade past the trial with one human approval: anyapi connect',
-  ].join('\n');
+    "This trial key has reached its spend cap. No charge was made for the blocked call.",
+    "Upgrade past the trial with one human approval: anyapi connect",
+  ].join("\n");
 }
 
 export function formatIdempotencyError(error: unknown): string | undefined {
-  if (!(error instanceof ApiError) || error.status !== 409 || !isRecord(error.body)) {
+  if (
+    !(error instanceof ApiError) ||
+    error.status !== 409 ||
+    !isRecord(error.body)
+  ) {
     return undefined;
   }
   switch (error.body.code) {
-    case 'idempotency_conflict':
-      return 'This idempotency key was already used for a different request. Use a new key, or retry with the original SKU and input.';
-    case 'idempotency_in_progress':
-      return 'The original request for this idempotency key is still running. Retry shortly with the same key.';
+    case "idempotency_conflict":
+      return "This idempotency key was already used for a different request. Use a new key, or retry with the original SKU and input.";
+    case "idempotency_in_progress":
+      return "The original request for this idempotency key is still running. Retry shortly with the same key.";
     default:
       return undefined;
   }
 }
 
 function trialCapServerMessage(error: unknown): string | undefined {
-  if (error instanceof ApiError && isRecord(error.body) && typeof error.body.message === 'string' && error.body.message.length > 0) {
+  if (
+    error instanceof ApiError &&
+    isRecord(error.body) &&
+    typeof error.body.message === "string" &&
+    error.body.message.length > 0
+  ) {
     return error.body.message;
   }
   return undefined;
@@ -162,5 +204,5 @@ function parseJson(raw: string, source: string): unknown {
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
diff --git a/src/types.ts b/src/types.ts
index 920c2b6..8212b04 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -140,4 +140,16 @@ export interface RunResult {
   [key: string]: unknown;
 }
 
+export type RequestStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'expired';
+export interface RequestSnapshot {
+  requestId: string;
+  sku: string;
+  status: RequestStatus;
+  createdAt: string;
+  retryAfterSeconds?: number;
+  result?: RunResult;
+  error?: { code: string };
+  resultExpired?: boolean;
+}
+
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;