# Slash commands — /every

> **What this chapter covers**
> What the `/` command does, why it doesn't send, and why "keep trying until it's
> done" became the default behaviour instead of a command.

## There is only one

Type `/` in the box and the list appears. There is one entry in it today.

| Command | What it does |
|---|---|
| `/every <cycle> <request>` | Turns what you are typing into a **repeat** |

> **There used to be a `/goal` alongside it.** It set "retry by yourself until this
> condition is met" — and that behaviour became **the default for every
> conversation**, so the command was removed. See "Retrying is the default" below
> for what runs in its place.

## /every — make it a repeat

```
/every daily summarise yesterday's sales into a table
```

The words it understands as cycles come from the **same table** as the
[scheduled screen](/guide/cn-queue).

```
hourly · daily · evening · weekly · friday · monthly
```

Korean words work too. For any other cycle, set a cron expression on the scheduled
screen.

### Why it doesn't send

`/every` **registers and stops there.**

> There is no reason to also do "every morning, do X" once right now. Sending it
> means only the author gets the first run twice.

A toast tells you where it was created.

### Why it lives in the message box

A request worth repeating is usually **the one that just worked**. And that
request's settings are already chosen in the box in front of you.

```
Already chosen right now:
  agent · model · group · withheld tools · drive scope
→ /every carries them over. The only thing left to pick is the cycle
```

Send people to a blank form on the scheduled screen and they have to pick all five
again — so nobody does.

## Retrying is the default — there is nothing to switch on

This is what changed from earlier versions of this manual.

> **Every conversation now keeps going until the result is reported.** There is no
> command and no screen to enable it.

### How the loop turns

When an agent finishes it **reports its own verdict** through `report_result`. That
report decides whether the loop turns again.

| Report | What happens next |
|---|---|
| `completed` | **Ends immediately.** A conversation that finishes in one shot never loops |
| `failed` + one line on what to do next | The system appends that line and runs **one more turn** |
| `blocked` (a human is needed) | Stops and asks for a person |

```
Default attempts   3
Hard cap           5
```

### Why the model doesn't write its own next prompt

If the model writes its whole next instruction, **the judge and the subject become
the same party.** It breaks in three ways in practice.

| Failure | How it looks |
|---|---|
| Self-confidence | Writes `failed` and then "almost there, wrap it up" — circling the same spot |
| Intent drift | The original request falls out of the history; a few turns later it is doing something else |
| Constraint loss | Summarising quietly drops conditions like "expired coupons use this wording" |

So the model owns **exactly one line — "what to do next"** — while the original
request and completion condition are re-attached **verbatim by the system** on every
turn. That is what stops the bottom two rows.

This is the product doing "restate the important constraints" from
[when context gets pushed out](/guide/ai-context-overflow) on your behalf.

### So what do you do instead?

The command is gone, so **the completion condition goes inside the request.**

```
✗ (before) /goal until every test passes
✓ (now)    Fix the tests on the login screen.
           Done when: the tests for wrong password / no such account /
           locked account all pass.
```

> **A completion condition has to be machine-checkable.** "Until it looks good" is
> not a condition. Same standard as the completion condition in
> [the four parts of a good instruction](/guide/ai-intent-context) — you now write
> it **in the body** rather than in a separate command.

## Typos just become messages

Mistype `/evrey daily …` and it is not recognised as a command — **it goes to the
model as text**, which reads it as an instruction. Picking from the list is safer.

**The removed `/goal` behaves the same way.** If it is still in your fingers,
`/goal ...` raises no error — the sentence simply goes to the model, which is more
confusing, not less, because it does not look like nothing happened. Put the
completion condition in the body instead.

## Common misunderstandings

### "Where do I edit what /every created?"

**On the [scheduled screen](/guide/cn-queue).** Once created it is identical to
one made there — editable, deletable, pausable.

### "Won't the retry loop run forever?"

**No.** Three attempts by default, five at most. And the moment the model reports
`completed` it stops, so short conversations never loop at all.

### "What if I want to turn retrying off?"

**There is no off switch on screen.** That is the point of making it the default —
it used to be off, so any conversation nobody switched it on for (which was nearly
all of them) ended right where the model stopped halfway. The only signal a person
got was a notification, and a notification tells you what finished; it cannot ask
for it again.

When calling from a program, setting `repeatMaxAttempts` to `0` **explicitly** in
the [API](/guide/cn-api) turns it off.

---

## Check yourself

**1. Why doesn't `/every` send?**

<details>
<summary>Answer</summary>

**Because it is work for later.** Sending it once more now would give the author
the first run twice. `/every` only registers, and a toast tells you where.
</details>

**2. Why is `/every` in the message box rather than the scheduled screen?**

<details>
<summary>Answer</summary>

**Agent, model, group, tools and drive scope are already chosen there.** Making
people pick them again in a blank form means nobody does it.
</details>

**3. What do you do to get "keep trying until it's done"?**

<details>
<summary>Answer</summary>

**Nothing.** Retrying is the default for every conversation (3 attempts, 5 max).
The only job left is to **write the completion condition into the request body**,
and that condition has to be machine-checkable.
</details>

**4. What happens if you mistype a command?**

<details>
<summary>Answer</summary>

**It goes out as a message.** The model reads it as an instruction, so picking
from the list is safer. The removed `/goal` also becomes a plain message rather
than an error.
</details>

---

Next, building agents → [What agents are](/guide/cn-agents-intro)
