---
title: "alis ideate"
url: "https://docs.alisx.com/reference/cli/ideate/"
---
# alis ideate

Read the context Ideate gathered for a project, add notes or files to it, and start and read web research.

## Synopsis

```bash
alis ideate add files (--project <project> | --new-project <title>) <file>... [--note <markdown>] [flags]
alis ideate add note (--project <project> | --new-project <title>) (--text <markdown> | --file <file>) [flags]
alis ideate add research (--project <project> | --new-project <title>) (--prompt <markdown> | --file <file>) [--reference <ref>]... [--continue <research>] [flags]
alis ideate artifacts read <output-artifact> [flags]
alis ideate context <project> [flags]
alis ideate contribution <contribution> --project <project> [flags]
alis ideate contributions <project> [flags]
alis ideate find <description> [flags]
alis ideate graph <project> [flags]
alis ideate list [flags]
alis ideate research <research> [--project <project>] [flags]
```

## Description

Ideate gathers context about a project from the people who hold it (notes, voice memos, uploaded documents and interviews with contributors) and synthesises it into artifacts: a brief, the pain points, the stakeholder map, the current process, a gap analysis. These commands read that context so whoever builds the thing starts from what was actually said. Voice memos, recordings and links stay with the console and the app.

Ideate's API still calls a project an idea and a contribution a stream, so resource names read `ideas/<id>` and `ideas/<id>/streams/<id>`; artifacts are `artifacts/<id>` (older ones `specs/<id>`). Every command accepts the bare id the `context` map prints, or the full resource name. Contribution ids need `--project`.

`context` is the entry point: one compact map of everything the project holds, with no bodies. Read only the parts that matter.

## Subcommands

### alis ideate add

Add to a project as your own contribution. Everyone on the project sees what you add. `add files` when someone may need to open the file itself; `add note` for everything else.

#### alis ideate add files

Upload one or more files to a project as a single contribution. Ideate reads each file and writes an overview of it; the files stay downloadable. A file's type comes from its extension: documents (pdf, docx, pptx, xlsx, csv, md, txt), images (png, jpg, webp), audio, video, code and zip. A type Ideate cannot read is rejected before anything is created.

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--new-project <title>` | string | | Start a project with this title and make the files its first contribution. |
| `--note <markdown>` | string | | What the files are and why they matter. |
| `--project <project>` | string | | The project to add the files to (`ideas/*` or the bare id). |
| `--yes` | bool | false | Skip the confirmation prompt (same as `--approve`). |

#### alis ideate add note

Add a markdown note to a project, stored as written.

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--file <file>` | string | | Markdown file holding the note (`-` reads stdin). |
| `--new-project <title>` | string | | Start a project with this title and make the note its first contribution. |
| `--project <project>` | string | | The project to add the note to. |
| `--text <markdown>` | string | | The note, as markdown. |
| `--yes` | bool | false | Skip the confirmation prompt (same as `--approve`). |

`--new-project` creates the project in your active account, the one `alis accounts` shows. There is no command that makes an empty project.

#### alis ideate add research

Start web research on a project, contributed by you. Google Deep Research reads the web and writes a cited report; most runs take five to twenty minutes. Returns as soon as the research has started. The research gets nothing from the project but the prompt and what you reference.

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--continue <research>` | string | | A finished research on the same project to follow up. |
| `--file <file>` | string | | Markdown file holding the prompt (`-` reads stdin). |
| `--new-project <title>` | string | | Start a project with this title and make the research its first contribution. |
| `--project <project>` | string | | The project to research for (`ideas/*` or the bare id). |
| `--prompt <markdown>` | string | | What to research, as markdown. |
| `--reference <ref>` | string, repeatable | | Context from the same project, up to 20: an artifact, or a contribution, optionally `<contribution>#1,3` for some of its files. |
| `--yes` | bool | false | Skip the confirmation prompt (same as `--approve`). |

### alis ideate artifacts read

Print an artifact's markdown. The bare id stands alone; `--project` is checked, not used to find the artifact, so an id from the wrong project fails instead of printing that project's document.

```bash
alis ideate artifacts read <output-artifact> [flags]
```

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--project <project>` | string | | The project the id came from; checked, not used to find the artifact. |

### alis ideate context

Print the map of one project: everyone involved, every artifact and every contribution, including completed interview evidence, each by its id with a line on what it covers. `--json` emits the same map as the underlying proto response. Compare `last activity` across runs to notice new material.

```bash
alis ideate context <project> [flags]
```

No flags beyond the global flags.

### alis ideate contribution

Print a single contribution (a note's text, a voice memo's or recording's transcript, the note an upload came with) as markdown, followed by a map of its files. `--file <n>` prints that file's extracted text; `--lines <a-b>` a slice of it. Download links expire in about twenty minutes.

```bash
alis ideate contribution <contribution> --project <project> [flags]
```

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--file <n>` | int32 | | Print this file's text instead of the map: its number in the file list. |
| `--lines <a-b>` | string | | With `--file`, the lines to print, as in `120-240`, `120-` or `-240`. |
| `--project <project>` | string | | The project a bare contribution id belongs to. |

### alis ideate contributions

List a project's contributions, oldest first, with who contributed each and what it is about.

```bash
alis ideate contributions <project> [flags]
```

No flags beyond the global flags.

### alis ideate find

Search projects semantically in your active account. Describe the topic in a sentence rather than keywords. Matching only works once Ideate has synthesised artifacts; an empty result means nothing matched, not that no such project exists.

```bash
alis ideate find <description> [flags]
```

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--dimension <facet>` | string | `brief` | Facet to match against: `brief`, `pain-points`, `stakeholders`, `technology`, `current-process`, `intent`. |
| `--limit <n>` | int | `20` | Maximum results to return. |

### alis ideate graph

Print the project's contribution graph: the people involved, the contributions they made and how they relate.

```bash
alis ideate graph <project> [flags]
```

No flags beyond the global flags.

### alis ideate list

List the Ideate projects you have access to, most recently updated first. Archived projects are hidden unless `--archived` is passed.

```bash
alis ideate list [flags]
```

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--archived` | bool | false | Include archived projects. |
| `--filter <cel>` | string | | CEL filter over Ideate's Idea resource, for example `Idea.state = 2` (overrides the default archived filter). |
| `--limit <n>` | int | `25` | Maximum projects to return. |

### alis ideate research

Print a research's question and how the run stands, then its summary, report and numbered sources once it is ready, or why it failed. Ideate checks a run every two minutes. `alis ideate context` lists a research among the contributions; pass its bare id with `--project`, or the full `ideas/*/streams/*` name on its own.

```bash
alis ideate research <research> [--project <project>] [flags]
```

| Flag | Type | Default | Meaning |
|---|---|---|---|
| `--project <project>` | string | | The project a bare research id belongs to. |

## Examples

```bash title="Terminal"
alis ideate list --json
alis ideate find "reducing onboarding time for new advisers" --json
alis ideate context my-project
alis ideate artifacts read <artifact-id> --project my-project
alis ideate contribution <contribution-id> --project my-project --file 2 --lines 120-240
alis ideate add note --project my-project --file note.md
alis ideate add files --project my-project deck.pdf --note "Board deck, Q3 priorities"
alis ideate add research --project my-project --file brief.md
```

## JSON output

`--json` returns the underlying proto response for each command; `contributions` prints a single section of the map. Related explanation: [Ideate](https://docs.alisx.com/explanation/ideate.md).