> ## 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.
# Checks methods
> Create task quality checks and read each checker’s result.
Create `client` with `checks()`. A **check id** identifies the group. Each `results[]` entry has a **task check id** identifying one checker run.
```text theme={"dark"}
Check: check.id
└── Task check: check.results[].id
├── Result and evidence
├── Transcript and logs
└── Sandbox files
```
Python returns check and task-check records as dictionaries. Use `check["id"]` and `check["results"]`.
| Work | Methods |
| ----------------- | ----------------------------------------------------------------------------------------------------------------- |
| Create and follow | [create](#create), [get](#get), [list](#list), [defaults](#defaults), [watch](#watch) |
| Read one checker | [task](#task), [transcript](#transcript), [artifact](#artifact) — TypeScript only |
| Files and sharing | [download](#download), [taskFilesystem](#taskfilesystem), [share](#share), [unshare](#unshare), [shares](#shares) |
## create
Check a local task directory, a directory of tasks, or a published dataset. Returns the accepted `Check` immediately.
```ts TypeScript signature theme={"dark"}
create(input: CreateCheckInput): Promise;
```
```python Python signature theme={"dark"}
async def create(
directory: Optional[str] = None,
*,
dataset: Optional[str] = None,
name: Optional[str] = None,
model_name: Optional[str] = None,
rubric: Optional[Rubric] = None,
prompt: Optional[str] = None,
reasoning_effort: Optional[str] = None,
sandbox_provider: Optional[EvalSandboxProvider] = None,
n_concurrent: Optional[int] = None,
include_task_names: Optional[List[str]] = None,
exclude_task_names: Optional[List[str]] = None,
n_tasks: Optional[int] = None,
on_upload_progress: Optional[Callable[[int, int], None]] = None,
) -> Check: ...
```
```ts TypeScript theme={"dark"}
const check = await client.create({
source: {
directory: "./tasks"
},
n_tasks: 2,
});
```
```python Python theme={"dark"}
check = await client.create(
'./tasks',
n_tasks=2,
)
```
| Source | Inputs |
| ----------------- | ------------------------------------------------------------------------------------- |
| Local directory | TypeScript: `source.directory`. Python: `directory` or the first positional argument. |
| Published version | TypeScript: `source.dataset`. Python: `dataset`. Use `name@version`. |
Supply exactly one source. A local source must be a directory, not an archive. `include_task_names` and `exclude_task_names` are glob lists; `n_tasks` caps the selected set after filtering. `n_concurrent` is bounded by organization capacity.
Optional `onUploadProgress(sent, total)` / `on_upload_progress(sent, total)` reports local transfer bytes. All omitted policy settings use [defaults](#defaults). The accepted check records the resolved policy. Follow with `watch(check.id)` / `watch(check["id"])`.
```ts theme={"dark"}
interface CheckConfigInput {
name?: string;
model_name?: string;
rubric?: Rubric;
prompt?: string;
reasoning_effort?: string;
sandbox_provider?: EvalSandboxProvider;
n_concurrent?: number;
include_task_names?: string[];
exclude_task_names?: string[];
n_tasks?: number;
}
interface CreateCheckInput extends CheckConfigInput {
source: { directory: string } | { dataset: string };
onUploadProgress?: (sentBytes: number, totalBytes: number) => void;
}
```
## get
Read a check at any status. Returns `Check`, including one task-check result per selected task.
```ts TypeScript signature theme={"dark"}
get(checkId: string): Promise;
```
```python Python signature theme={"dark"}
async def get(check_id: str) -> Check: ...
```
```ts TypeScript theme={"dark"}
const check = await client.get(checkId);
```
```python Python theme={"dark"}
check = await client.get(check_id)
```
Use the group’s check id. See [all check fields](/sdk-reference/types#analysis-and-check-results).
## list
List visible checks, newest first. Returns a page or an iterable of `Check`.
```ts TypeScript signature theme={"dark"}
list(options?: ListChecksOptions): CheckList;
```
```python Python signature theme={"dark"}
def list(
*,
scope: Optional[JobListScope] = None,
status: Optional[List[CheckStatus]] = None,
dataset: Optional[str] = None,
limit: Optional[int] = None,
cursor: Optional[str] = None,
) -> _PaginatedList: ...
```
```ts TypeScript theme={"dark"}
const page = await client.list({
dataset: "my-tasks@1.0",
status: ["completed"]
});
```
```python Python theme={"dark"}
page = await client.list(
dataset='my-tasks@1.0',
status=['completed'],
)
```
Optional `scope`: `my` (default), `shared`, or `org`; `status`: a list of `queued`, `running`, or `completed`; `dataset`: a bare name or pinned `name@version`. `limit` defaults to 50 (maximum 200); `cursor` continues a page.
## defaults
Read `CheckDefaults`: current model, reasoning effort, sandbox provider, rubric, and unrendered prompt template.
```ts TypeScript signature theme={"dark"}
defaults(): Promise;
```
```python Python signature theme={"dark"}
async def defaults() -> CheckDefaults: ...
```
```ts TypeScript theme={"dark"}
const defaults = await client.defaults();
```
```python Python theme={"dark"}
defaults = await client.defaults()
```
Python returns a dictionary. The check’s prompt uses `{task_path}`, `{file_tree}`, and `{criteria_guidance}`; the output contract is appended after your template.
## watch
Wait until every task check has settled. Returns the final `Check`, which may contain failed task checks.
```ts TypeScript signature theme={"dark"}
watch(
checkId: string,
options?: WatchCheckOptions
): Promise;
```
```python Python signature theme={"dark"}
async def watch(
check_id: str,
*,
on_progress: Optional[Callable[[Check], None]] = None,
poll_interval_s: float = 2.0,
timeout_s: Optional[float] = None,
) -> Check: ...
```
```ts TypeScript theme={"dark"}
const check = await client.watch(checkId, {
onProgress: c => console.log(c.status)
});
```
```python Python theme={"dark"}
check = await client.watch(
check_id,
on_progress=lambda c: print(c['status']),
)
```
Optional `onProgress(check)` / `on_progress(check)` runs when per-task statuses change. `pollIntervalMs` / `poll_interval_s` defaults to 2 seconds, doubles while unchanged to 30 seconds, and resets on change. TypeScript accepts `signal`; Python accepts `timeout_s`.
## task
TypeScript only. Read one checker’s `TaskCheck` result at any status.
```ts TypeScript signature theme={"dark"}
task(taskCheckId: string): Promise;
```
```ts TypeScript theme={"dark"}
const result = await client.task(taskCheckId);
```
Use `check.results[].id`, not the group’s id. Python reads the same result within `check["results"]`. The result contains `checks`, attempts, measured cost, and typed failure.
## transcript
TypeScript only. Read one checker’s own activity. Returns `TaskCheckTranscript`.
```ts TypeScript signature theme={"dark"}
transcript(
taskCheckId: string,
options?: AnalysisTranscriptOptions,
): Promise;
```
```ts TypeScript theme={"dark"}
const transcript = await client.transcript(taskCheckId, {
since: 0
});
```
Optional `since` skips that many events; default 0. No server pagination. `total` counts all stored events; `gateway_calls` is separate and returned whole. [Transcript fields](/sdk-reference/types#analysis-and-check-results) include the owning `check_id` and dataset.
## artifact
TypeScript only. Read one checker’s stored stdout, stderr, or captured home.
```ts TypeScript signature theme={"dark"}
artifact(
taskCheckId: string,
stream: Exclude,
): Promise;
artifact(
taskCheckId: string,
stream: "agent-home",
): Promise | null>;
```
```ts TypeScript theme={"dark"}
const stderr = await client.artifact(
taskCheckId,
"trace-stderr"
);
```
Use the task check id. `trace-stdout` and `trace-stderr` return `string | null`; `agent-home` returns a path-to-text map or null. Null means not stored. Python can read stored evidence from `download(task_check_id)`.
## download
Download a settled whole check or one task check as a `.tar.gz`. Both id forms use the same method.
```ts TypeScript signature theme={"dark"}
download(id: string): Promise;
download(
id: string,
options: { to: string }
): Promise;
download(
id: string,
options: { stream: true }
): Promise>;
download(
id: string,
options?: DownloadJobOptions
): Promise>;
```
```python Python signature theme={"dark"}
async def download(
id: str,
*,
to: Optional[str] = None,
) -> bytes | str: ...
```
```ts TypeScript theme={"dark"}
const path = await client.download(checkId, {
to: "./results"
});
```
```python Python theme={"dark"}
path = await client.download(
check_id,
to='./results',
)
```
Omit options for `Buffer` / `bytes`; use `to` for a saved file path. TypeScript also accepts `{ stream: true }`, a raw stream whose integrity the caller verifies. Python has no stream option. A live group or task check returns `check_not_terminal`. The group archive includes `check_report.json` and each checker’s wrapper trial.
## taskFilesystem
Python: `task_filesystem`. Get one checker’s `RunFilesystem`. Requires both the group id and task check id.
```ts TypeScript signature theme={"dark"}
taskFilesystem(
checkId: string,
taskCheckId: string
): RunFilesystem;
```
```python Python signature theme={"dark"}
def task_filesystem(
check_id: str,
task_check_id: str,
) -> 'RunFilesystem': ...
```
```ts TypeScript theme={"dark"}
const fs = client.taskFilesystem(checkId, taskCheckId);
```
```python Python theme={"dark"}
fs = client.task_filesystem(
check_id,
task_check_id,
)
```
See [filesystem methods](/sdk-reference/methods/filesystem) for files, sandbox logs, and processes.
## share
Grant read access to a check you created. Returns `JobShares`, the same share-state shape used by jobs.
A check can have up to 50 email grants.
```ts TypeScript signature theme={"dark"}
share(
id: string,
request: JobShareRequest
): Promise;
```
```python Python signature theme={"dark"}
async def share(
id: str,
*,
link: bool = False,
emails: Optional[List[str]] = None,
) -> JobShares: ...
```
```ts TypeScript theme={"dark"}
const shares = await client.share(checkId, {
link: true
});
```
```python Python theme={"dark"}
shares = await client.share(
check_id,
link=True,
)
```
Supply `link: true` / `link=True`, `emails: string[]` / `emails=[...]`, or both. New email grants send invitations. Recipients can read the check, its task checks, and downloads. They cannot operate it. [Share-state fields](/sdk-reference/types#sharing-and-deletion) describe the result.
## unshare
Revoke a check’s link or email grants. Returns `JobShares`. Creator-only and idempotent.
```ts TypeScript signature theme={"dark"}
unshare(
id: string,
request: JobShareRequest
): Promise;
```
```python Python signature theme={"dark"}
async def unshare(
id: str,
*,
link: bool = False,
emails: Optional[List[str]] = None,
) -> JobShares: ...
```
```ts TypeScript theme={"dark"}
const shares = await client.unshare(checkId, {
link: true
});
```
```python Python theme={"dark"}
shares = await client.unshare(
check_id,
link=True,
)
```
Takes the same `link` and `emails` fields as `share`.
## shares
Read the check’s whole share state: visibility, link, and email grants. Creator-only.
```ts TypeScript signature theme={"dark"}
shares(id: string): Promise;
```
```python Python signature theme={"dark"}
async def shares(id: str) -> JobShares: ...
```
```ts TypeScript theme={"dark"}
const shares = await client.shares(checkId);
```
```python Python theme={"dark"}
shares = await client.shares(check_id)
```