While the agent works

A long run used to mean a greyed-out message box and a lot of waiting. It doesn’t any more. The conversation stays live while the agent works, and this page covers what the controls do.

Queue the next message, or steer this one

The message box never locks. What happens when you send depends on which key you press:

Key	What it does
`Enter`	Queues your message as the next turn. A slim Queued · runs next chip appears, with an × to withdraw it.
`⌘`/`Ctrl` + `Enter`	Steers now — the agent picks your message up mid-run and adjusts course.

The hint under the box says the same thing, so you don’t have to remember.

Use steer for a correction that matters right now — “stop, that’s the wrong repository”. Use queue for the next thing you want done, so you don’t have to sit and watch for the finish. A queued message runs automatically when the current one ends.

If your organization has several runs going at once, a queued message may sit behind them; the indicator tells you how many are ahead. Nothing fails for waiting — although a message that has queued for hours is released with a note asking you to send it again, rather than surprising you by running much later.

Steers are never quietly lost

When a run ends before the agent picks up your steer, the steer goes into one follow-up turn instead. Its marker says Carried over — running as the next turn. When it can’t be carried (you cancelled the run, say), it’s marked Not acted on, with the reason. Either way you can see what happened to it.

Questions you can answer whenever

Sometimes the agent wants your input but can carry on without it: a preference, or a choice between two reasonable options. Those come as a card tagged You can answer anytime — I’m continuing. The run keeps going.

Answer while it’s still working and it takes your answer into account from that point. Answer after it’s finished and your answer carries into the next turn. Ignore it and nothing breaks.

That is different from a genuine approval, which does stop and wait — see Autonomy & approvals.

When a run reaches its budget

Long runs have a ceiling — a wall-clock budget and a limit on how many steps the agent takes — so a run can never quietly burn your credits forever.

When a run reaches it, it doesn’t just stop. The agent takes one short final turn to tell you where it got to: what’s done, what remains, and what it would do next. Then the conversation shows:

Reached this run’s budget Nothing was lost — continue to keep going. Continue · Dismiss

Continue starts a fresh run from that state. Nothing is lost — the plan, the notes and the files are all still there.

When the conversation gets condensed

Every model has a limit on how much it can hold at once. On a long conversation, Auteryn summarises the earliest part to make room — and tells you it did:

Context condensed — 37 earlier steps summarised · Show

Show opens the summary, so you can check that the thing you care about survived.

You can also do it deliberately. The context ring, at the right of the message box, has Compact now in its card, with a field asking What must survive? — “keep the API schema and the failing test’s output word for word”. The summary is then written to your instruction rather than to a generic one, and the chip afterwards notes that your instructions were applied. Compaction happens at the start of your next message, so nothing is interrupted.

If there’s something an agent should always keep, put it on the agent instead: the Console has a What to keep when the conversation is condensed field per agent, and it applies to every conversation with it.

If something goes wrong mid-run

Runs survive the infrastructure underneath them restarting. When a run is picked back up after an interruption:

Nothing is done twice. A run that had only read things so far is picked up again, and the results of those steps are replayed rather than fetched again. A run that had already changed something (sent an email, written a file) is stopped instead of re-run, so none of it happens a second time.
A pending approval survives. If a run was interrupted while waiting for you, the request is still there when you come back, and the conversation makes sense around it rather than showing a half-finished action with no explanation.

What sits above the message box

At most two rows appear between the conversation and the message box:

Row	What it shows
One card	The newest thing waiting on you: an approval, a question, or a plan that needs your go-ahead. If more are waiting, the line below counts them (+2 waiting). With nothing waiting, the card is for a run that reached its budget, a Goal that needs you, or a Skill that was just installed.
One line of status	Short parts, each only while it is true: the current step when the reply showing it is out of view, the plan’s progress (`Plan 2/4`), the Goal, what is waiting, what runs in the background, the Loop and when it runs next, Preparing computer…, and low credits.

During a voice call the status line stays above the call bar and keeps only the connection, what is waiting, background work and credits.

Everything else stays in the conversation where it happened. A plan the agent approved for itself is a collapsed one-liner at the turn that wrote it: open it if you want the steps, ignore it if you don’t. A Goal shows in the status line, and becomes a card only when it is about to work unattended, has used more than half its budget or stopped at a cap. A run that failed or was stopped ends with its card in the conversation, not above the message box.

If the computer is still being set up when you open a conversation, a small pill says so. If that takes more than three minutes it turns into Still preparing your computer · Retry, and Retry does what it says.

After you press Stop

Stop ends the run that is executing. Anything you typed as a steer that the agent had not picked up yet is dropped and marked Not acted on, so you can see the agent never read it.

The next message you send starts a new run. It is never treated as a correction to the run you stopped. If you had a message queued behind the stopped run, it stays queued and runs next.