> ## Documentation Index
> Fetch the complete documentation index at: https://docs.evolvingmachines.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Analyses methods

> Read the analyzer’s result, transcript, files, and current defaults.

Create `client` with `analyses()`. Start a wave with [jobs.analyze](/sdk-reference/methods/jobs#analyze), then read its results here.

<Note>
  Python exposes `list`, `defaults`, `download`, and `filesystem`. Direct `get`, `transcript`, and `artifact` reads are TypeScript-only. In Python, `list(job=...)` or `Trial.analysis` gives the result; an analysis download gives its stored evidence.
</Note>

| Both SDKs                                                                              | TypeScript only                                               |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
| [list](#list), [defaults](#defaults), [download](#download), [filesystem](#filesystem) | [get](#get), [transcript](#transcript), [artifact](#artifact) |

## list

List visible analyses, newest first. Returns one page or an iterable of `TrialAnalysis`.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    list(options?: ListAnalysesOptions): AnalysisList;
    ```

    ```python Python signature theme={"dark"}
    def list(
        *,
        scope: Optional[JobListScope] = None,
        job: Optional[str] = None,
        status: Optional[List[AnalysisStatus]] = None,
        limit: Optional[int] = None,
        cursor: Optional[str] = None,
    ) -> _PaginatedList: ...
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const page = await client.list({
    job: jobId,
    status: ["completed"]
  });
  ```

  ```python Python theme={"dark"}
  page = await client.list(
      job=job_id,
      status=['completed'],
  )
  ```
</CodeGroup>

Optional `scope`: `my` (default), `shared`, or `org`; `job`: source job id; `status`: list of `queued`, `running`, `completed`, or `failed`. `limit` defaults to 50 (maximum 200); `cursor` continues a page.

Python analysis rows are dictionaries: `row["id"]`, `row["checks"]`. [Analysis result fields](/sdk-reference/types#analysis-and-check-results) include failures and cost as well as the per-criterion checks.

## defaults

Read the current analysis defaults. Returns `AnalyzeDefaults`: model, effort, sandbox provider, rubric, and unrendered prompt template.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    defaults(): Promise<AnalyzeDefaults>;
    ```

    ```python Python signature theme={"dark"}
    async def defaults() -> AnalyzeDefaults: ...
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const defaults = await client.defaults();
  ```

  ```python Python theme={"dark"}
  defaults = await client.defaults()
  ```
</CodeGroup>

Python returns a dictionary. These are current defaults; an existing analysis records the policy it actually ran under.

## get

TypeScript only. Read one `TrialAnalysis` at any status, including an earlier analysis no longer attached to `Trial.analysis`.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    get(analysisId: string): Promise<TrialAnalysis>;
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const analysis = await client.get(analysisId);
  ```
</CodeGroup>

Takes one analysis id. Missing or inaccessible records return `analysis_not_found`.

## transcript

TypeScript only. Read the analyzer’s own activity, not the evaluated agent’s trace. Returns `AnalysisTranscript`.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    transcript(
      analysisId: string,
      options?: AnalysisTranscriptOptions,
    ): Promise<AnalysisTranscript>;
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const transcript = await client.transcript(analysisId, {
    since: 0
  });
  ```
</CodeGroup>

Optional `since` is the number of events already read (nonnegative integer, default 0). There is no server-side pagination. `total` counts all stored events; `events` starts at `since`. `gateway_calls` is returned separately in full on each read. See [transcript fields](/sdk-reference/types#analysis-and-check-results).

## artifact

TypeScript only. Read the analyzer’s stored stdout, stderr, or captured home.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    artifact(
      analysisId: string,
      stream: Exclude<AnalysisArtifactStream, "agent-home">
    ): Promise<string | null>;
    artifact(
      analysisId: string,
      stream: "agent-home"
    ): Promise<Record<string, string> | null>;
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const stderr = await client.artifact(
    analysisId,
    "trace-stderr"
  );
  ```
</CodeGroup>

`trace-stdout` and `trace-stderr` return `string | null`; `agent-home` returns `Record<string, string> | null`. Null means not stored. Analyses do not expose trial `verifier` or `trace-atif` artifact selectors.

## download

Download a settled analysis as a `.tar.gz` containing its wrapper trial, transcript, logs, and available result artifacts.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    download(analysisId: string): Promise<Buffer>;
    download(
      analysisId: string,
      options: { to: string }
    ): Promise<string>;
    download(
      analysisId: string,
      options: { stream: true },
    ): Promise<ReadableStream<Uint8Array>>;
    download(
      analysisId: string,
      options?: DownloadJobOptions
    ): Promise<Buffer | string | ReadableStream<Uint8Array>>;
    ```

    ```python Python signature theme={"dark"}
    async def download(
        analysis_id: str,
        *,
        to: Optional[str] = None,
    ) -> bytes | str: ...
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const path = await client.download(analysisId, {
    to: "./results"
  });
  ```

  ```python Python theme={"dark"}
  path = await client.download(
      analysis_id,
      to='./results',
  )
  ```
</CodeGroup>

Omit delivery options to return `Buffer` / `bytes`; `to` saves to a directory and returns a path. TypeScript also accepts `{ stream: true }`, returning a raw `ReadableStream<Uint8Array>` that the caller must verify. Python has no stream option. Queued or running analyses return `analysis_not_terminal`.

## filesystem

Get the analyzer’s `RunFilesystem`, including its live or captured files, sandbox logs, and process list.

<Accordion title="Signature">
  <CodeGroup>
    ```ts TypeScript signature theme={"dark"}
    filesystem(analysisId: string): RunFilesystem;
    ```

    ```python Python signature theme={"dark"}
    def filesystem(analysis_id: str) -> 'RunFilesystem': ...
    ```
  </CodeGroup>
</Accordion>

<CodeGroup>
  ```ts TypeScript theme={"dark"}
  const fs = client.filesystem(analysisId);
  const status = await fs.status();
  ```

  ```python Python theme={"dark"}
  fs = client.filesystem(analysis_id)
  status = await fs.status()
  ```
</CodeGroup>

This is the analyzer’s sandbox, separate from the trial it analyzed. See [filesystem methods](/sdk-reference/methods/filesystem).