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

# Prompting

> How to ask nemu chat for what you actually want

The agent in nemu chat plans, calls tools and works in steps. It reads a request
the way a colleague would, so the things that make a good ticket make a good
prompt.

## Say what finished looks like

The single biggest difference in output quality comes from naming the end state
rather than the next action.

<CodeGroup>
  ```text Weaker theme={null}
  look at my database
  ```

  ```text Stronger theme={null}
  Connect to my Postgres connector and tell me which tables have grown
  the most in the last week. I want a short list, biggest first.
  ```
</CodeGroup>

The second version names the source, the question and the shape of the answer,
so the agent does not have to guess at any of the three.

## Give it the material

The agent can only reason over what it can reach. Attach the file, paste the
error, name the repository. A screenshot of a stack trace is worth more than a
description of one.

Attachments are indexed and searched rather than pasted whole, so a large
document costs far less than it looks like it should. Send the whole thing.

## Let it work in steps

Long tasks run as a series of tool calls, and the agent will tell you what it is
doing as it goes. You do not need to break a task into ten messages. One clear
request that ends in a deliverable usually beats ten that each move it a little.

If it goes the wrong way, say so plainly and it will change course. You do not
have to start a new chat.

## Ask for the format you want

If you want a table, ask for a table. If you want a file, ask for a file. The
agent can produce documents, PDFs, charts and running code, but it defaults to a
written answer unless you say otherwise.

```text theme={null}
Summarise these three reports and give me a PDF with one page per report
and a chart of the totals.
```

## Say what not to do

Constraints are as useful as instructions, and they are cheaper than corrections.

```text theme={null}
Refactor this file. Do not change the public API and do not touch the tests.
```

## When a tool needs permission

Anything that writes gets your approval first. Database writes, dangerous shell
commands and connector changes all pause and ask. Approving a pattern once
remembers it, so a task that touches the same kind of operation repeatedly only
asks you the first time.

If you would rather it never asked, say what is safe up front:

```text theme={null}
You can run any read only query without asking. Ask before anything
that writes.
```

## Picking a model

The model selector sits under the composer, and every model your workspace has
enabled appears there. Reasoning models are worth the extra latency for
planning, debugging and anything with more than one moving part. For
summarising, rewriting and short answers, a faster model is usually the better
trade.

Related: [How the gateway works](/setup/gateway) for what happens to a request
after you send it.