Step 3: The prompt bar is not the terminal

There are two boxes on this screen you can type into, and the first time you notice it, it looks like a mistake. The terminal fills the middle of the window and the agent has its own input line at the bottom of it. Then there is a second box below the whole terminal, with Send, Speak and Queue down its side.

They are both real, and the difference between them is the most useful thing to understand about the Director. The agent's line is live: every key you press in the terminal is already in the agent's hands, one character at a time, and it is one line long. The box below holds what you write and gives it to nobody until you say so - so you can take five minutes over a paragraph, read it back, change your mind, and say it out loud instead of typing it.

Ten minutes. You need DevThrottle open with one session running, from the previous step, and the Terminal tab showing.

1. Write more than one line, slowly

   Click into the lower box - the one under the terminal - and start typing the next thing you want the agent to do. Not six words: the whole thing. The file you already looked at, the approach you do not want, the reason. Press Enter when you want a new line; Enter on its own is a line break here, not a send.

   Watch the terminal above while you do it. Nothing is happening. The agent is carrying on with whatever it was doing and has no idea you are typing, because this box is not connected to it yet. That is the whole point of the second box, and it is why you can write a careful instruction to an agent that is in the middle of something.

2. Open it out into the larger editor

   A paragraph is uncomfortable in a box that size. Click Expand in the top-right corner of the box and the same text opens in a large, resizable editor window with room to work - your text on the left, a preview beside it, and a Speak button in the corner if you would rather talk than type.

   Edit it properly there. Apply brings your edited text back into the box; Cancel leaves it as it was. Neither one sends anything - you come back to exactly where you were, with better words in the box.

3. Say it instead of typing it

   The instruction you would give a person out loud is longer and clearer than the one you are willing to type. Click the green Speak button, or press Ctrl+H from anywhere in the window while a session is selected, and talk.

   When you stop, Insert drops what you said into the box at your cursor - inside anything you had already typed, not on the end of it - so dictating is just another way of filling the same box. Send submits it straight away. Everything else about dictation, including what it costs and what to do when the words come out wrong, is its own tutorial: Say it instead of typing it.

4. Send it, and watch where it lands

   Press Ctrl+Enter, or click Send. Now look at the terminal: your message appears in the agent's own input line, as if you had typed it there, and then submits. That is exactly what happened: DevThrottle put your message into the agent's own line and pressed Enter for you.

   It does not then walk away and hope. After pressing Enter it watches the terminal until the agent visibly starts the turn, and nudges it if the message is sitting there unsent - which is what stops a prompt being quietly swallowed by an agent that was busy repainting its screen. If a message genuinely cannot be delivered, the session says so rather than losing it silently.

   One consequence worth knowing, because it surprises people: the line breaks you typed were for you, not for the agent. On send, your message is joined into a single line, because the agent's input is a single line. Your paragraph arrives whole; it just arrives flat.

5. Send something far too long for one line

   Now do the thing a terminal will not let you do. Write - or dictate - a message several hundred words long and send it. It still arrives whole, and it is not truncated.

   Typing a very long message into an input line one character at a time is exactly where a terminal drops text, so DevThrottle does not do that. It hands the message over in one piece instead, by whichever means the agent in front of it understands - some accept a whole block pasted at once, others are given a file to read. Which one you get depends on the coding agent, and you do not choose it.

   What holds either way is the part that matters: your message arrives whole and is not cut short, however long it is.

   If your agent is one of the ones given a file, you will see a .temp folder appear in the repository, holding the text you sent in files named input_ and a timestamp. Those stay where they are - nothing removes them for you - so they build up quietly over a long session. They are only copies of your own messages, and you can delete those input_ files once no session still needs them. Leave the rest of the folder alone: DevThrottle does not own it, and other things keep working files there too.

6. Queue what comes next instead of interrupting

   You will think of the next job while the agent is still on this one. Interrupting a working agent to say it is a bad trade, and holding the thought means being there at the moment it finishes.

   Write it in the box as normal, then press Ctrl+Shift+Enter - or click Queue, under Send and Speak. The box empties and your instruction is queued on this session. The Queue button turns red and starts counting, reading Queue (1), and the list appears in the panel on the right.

   Nothing in the queue is sent until you send it. DevThrottle does not wait for the agent to finish and feed it the next item - a stopped agent has either finished or stopped to ask you something, and those look the same from outside. The queue is a notepad with an order to it, attached to the right session.

   That is enough to start the habit. Sending items back out, reordering them, editing one you wrote an hour ago, and what survives a restart are all in Line up the next instruction.

When you do want to type in the terminal

There is one moment the agent's own line is the right box: when the agent's tool stops and asks for a keypress - an arrow-key menu, a yes-or-no confirmation, a pager. Click into the terminal and answer it directly. Arrows, Enter, function keys and the control strokes a command-line tool leans on - Ctrl+C, Ctrl+D, Ctrl+Z and Ctrl+L - pass straight through to the agent, exactly as if you had started it yourself.

For everything longer than a keypress, come back down to the box. It is the intended way to talk to an agent; the terminal above it is chiefly your window into what the agent is doing. Every control and shortcut in one place is on The embedded terminal.

Next

You can compose, expand, dictate, send and queue. The next step is what to do when the answer coming back is wrong - stopping an agent, redirecting it, and knowing when to take over rather than let it run: steering a session that is going wrong.

The step after that is showing the agent a picture instead of describing one - dragging a screenshot onto this same box: Work with pictures.