An **idea** is where a request enters the pipeline. You describe what you want; the agent
turns it into elaboration questions until you both share the same understanding; then you
resolve it so a proposal can be drafted. This guide covers creating an idea, running one or
more elaboration rounds, confirming, and resolving — and how a theme idea differs from a
derived child idea.

## Create an idea

Ideas live on the project **Overview**, in the idea tracker.

1. Open the project **Overview**. The tracker has a segmented switch for **Ideas**,
   **Lineage**, and **Stats** views, and a **New Idea** button.
2. Select **New Idea**. The dialog offers two modes:
   - **Fill a form** — enter a **Title** ("What's the idea?") and an optional
     **Description** with context, goals, or details.
   - **Describe to an agent** — talk through the idea conversationally instead. This mode
     needs an online agent runtime; it is disabled when none is connected.
3. Select **Create**.

The new idea appears in the tracker with a status badge that starts at **Open**.

## Describe an idea to an online agent

Instead of filling the form, you can hand the idea to a connected agent and let it draft,
elaborate, or decompose the idea for you. This is the **conversational** path, and it needs
an [online agent](/guides/online-agents-overview/): with none connected, the **Describe to
an agent** tab shows a hint to connect a runtime instead of opening a conversation.

In the New Idea dialog:

1. Switch to the **Describe to an agent** tab.
2. Pick the **Agent** you want to talk to, then its **Working directory**. If that agent has
   a single online directory it is selected for you; if it has more than one, choose which
   one before you can send. When the project already has a
   [fixed working directory](/guides/create-a-project/), that fixed directory is used and
   there is nothing to pick.
3. Optionally check **Help me break this into child ideas** to have the agent propose a set
   of child ideas (a decomposition) rather than a single idea.
4. Optionally check **Research before clarifying** to have the agent check the facts it
   needs before it asks you anything. Leaving it unchecked does not forbid research — the
   agent still looks something up when a checkable fact could change what it asks you. When
   the goal itself is unclear, it asks you first rather than searching.
5. Type a description of what you want and select **Send to agent**.

Chorus creates the idea, assigns it to the agent and working directory you picked, and hands
it to that agent. The dialog closes and confirms that the request was submitted; you stay on
the page you were on. From there the agent takes over: it gives the idea a proper title,
polishes your description, and starts elaboration. An idea created this way therefore arrives
already assigned and in elaboration, and you answer its questions in the idea's Elaboration
tab (below). If you checked the decompose option, the agent instead proposes candidate child
ideas for you to confirm.

The request also starts a conversation with the agent, tied to the new idea. It does not
open by itself; to watch the agent work, select the online-agents indicator in the
bottom-right corner, then **Open chat**. The request shows there as a **Create Idea** turn.

Because this path assigns the agent for you, you can skip the manual **Assign** step in the
next section.

![New Idea dialog on the Describe to an agent tab, showing the agent select, working-directory picker, description box, and Send to agent button](/images/agent-operations/conversational-idea-entry.webp)

## Get an agent onto the idea

An agent runs elaboration, so the idea needs one assigned. Open the idea and use **Assign**
to give it to an agent (the **Describe to an agent** entry does this for you when a runtime
is online). Once assigned, an online agent picks the idea up and posts the first round of
questions; if no agent is connected yet, bring one online first — see the
[agent platforms reference](/reference/agents/).

## Ask for research before development

Sometimes an idea needs facts before it needs questions — how comparable products solve
this, what a library actually supports, whether an approach has a known catch. You can ask an
agent for one short research pass: open the idea, select **Actions**, then **Research**.

- **Assign an agent first.** Research requires an assigned agent that you own, with
  permission to read the plan, edit ideas, and attach references. With no
  assignee or a human assignee, the action stays visible but disabled and tells you to assign
  an agent.
- **Bring that agent online.** At least one of the assigned agent's connections must be
  online. Another agent's connection or a stale connection is not enough. Availability
  updates as assignment and presence change, without reloading the page. Hover or focus the
  disabled action to read the reason; the action sheet shows it inline.
- If the assigned agent's new Research conversation needs a working-directory choice,
  choose it when prompted. An online indicator does not guarantee that the required
  directory is still available: Chorus checks the target again and reports a failure if it
  has changed or disconnected. An accepted request leaves the idea's current stage and
  questions unchanged.
- Research is available **only before development starts**. Once execution begins, or the
  idea is already complete, the action is disabled and says which of the two applies.
- You can ask more than once. Each request is queued for the agent and shows up in the
  idea's conversation as a **Research** turn. The conversation does not open by itself; open
  it from the online-agents indicator (**Open chat**), as described above, to follow what the
  agent did.

Findings go into the idea's own description, each with an inline
[citation](/guides/references/#read-inline-citations) to the source it came from, and those
sources appear in the idea's [references](/guides/references/). There is no separate research
report to open.

:::note[What the agent does]
The agent decides what is worth checking and keeps the pass short. It adds only findings that
change this idea; if nothing useful turns up, it says so rather than inventing evidence. It
looks up facts; your goals and preferences still come from elaboration.
:::

![Idea panel Actions menu opened before development, with Research as the first item above Verify Elaborate, Start Development, and Yolo](/images/workflow/idea-research.webp)

## Run elaboration

Elaboration is a short, structured back-and-forth that pins down the requirement before any
proposal is written. Open the idea to see its detail panel, then select the **Elaboration**
tab.

Elaboration proceeds in **rounds**. Each round is a set of questions, and you answer them
one round at a time:

1. The agent posts a round of questions under **Requirements Elaboration**, each with
   options (and an **Other** free-text choice).
2. Answer every question in the round, then select **Submit answers**. The panel tracks
   progress as "_n_ of _m_ answered".
3. Your answers may raise new questions or reveal a gap. When they do, the agent opens
   another round. Keep answering rounds until nothing is left open — elaboration is a loop,
   not a single pass.

If the request is trivially clear (for example, a bug fix with exact steps), the agent may
offer to **Skip Elaboration** instead of asking questions.

:::note[What the agent does]
The agent writes the elaboration questions from your idea, reads your answers, and decides
whether another round is needed. You only ever answer and confirm — the agent drives the
questioning. For how an agent connects and acts on your project, see the
[agent platforms reference](/reference/agents/).
:::

![Idea Elaboration tab showing one round of requirement questions with selected answers](/images/workflow/idea-elaboration.webp)

## Confirm the shared understanding

Before resolving, make sure the answers really capture what you want. The agent typically
summarizes its understanding and mentions you in a comment to check. Read that summary:

- If it matches your intent, you are ready to resolve.
- If something is off or a new concern surfaces, say so. The agent opens a fresh round
  rather than resolving, and you answer again.

Confirming is the gate — nothing resolves until you are satisfied.

## Resolve elaboration

Resolving marks the whole elaboration phase complete and signals that a proposal may be
drafted. On the idea panel, select **Verify Elaborate**. This confirms the shared
understanding and moves the idea from elaborating to **elaborated**.

Its status badge advances (for example to **Planning** / **Review proposal**), and the
idea is ready for the proposal stage. Later progress — planning, building, verifying, done —
updates automatically from the idea's linked proposals and tasks.

:::note[What the agent does]
When you select **Verify Elaborate**, Chorus resolves the elaboration and — if the idea's
assigned agent is online — has the agent start writing the proposal. You do not draft the proposal
yourself; the agent produces the documents and task drafts and submits them for your
review. See the [agent platforms reference](/reference/agents/) for how that connection
works.
:::

![Idea panel footer with the Verify Elaborate action ready to resolve elaboration](/images/workflow/idea-verify-elaborate.webp)

## Theme ideas versus derived child ideas

Most ideas are single deliverables. Two related shapes help you organize larger work:

- A **theme** is an idea that only *groups* related child ideas under a shared direction —
  it is not delivered on its own. Create one by checking **Make this a theme** in the New
  Idea dialog, or flip the **Theme** switch later on the idea's Overview tab. A theme can
  elaborate to set shared context, but **a theme cannot become a proposal**: to deliver its
  direction, you derive a child idea and write the proposal there. A theme shows a progress
  ring that rolls up from its children.
- A **derived (child) idea** is a full idea with its own elaboration, proposal, and tasks,
  linked to a parent. To create one, open the parent idea and select **Derive** in the
  panel header. Reach for a derived idea when a new direction needs its own end-to-end
  lifecycle; add a task to the current proposal instead when the work is just *how* to build
  the current idea.

A parent shows a "_n_ derived" rollup of its direct children. This lineage is informational
— it never blocks either idea's flow. The **Lineage** view in the tracker visualizes the
parent-child tree.

![Idea tracker Lineage view showing a theme idea with two derived child ideas](/images/workflow/idea-lineage.webp)

## Next

Once elaboration resolves and the agent submits a proposal, continue to
[Review a proposal](/guides/review-a-proposal/).