Talking with agents

An agent that runs on a machine of yours, with nobody watching, still needs a person now and then: it wants to know which option you prefer, or asks before it runs a command. With instruction.md it asks you, wherever you are, and waits for your answer. You can also tell a running agent something, or stop it, without touching the machine.

When an agent asks

Its request appears on the Deployments page under Your agents ask you, and you get a notification. There are two kinds:

  • A question with choices. Pick one (or several, where it says so), or write your own answer.
  • A permission to use a tool, with what it would do, such as the command it would run. Choose Allow, Allow for this run (it won't ask again for the same kind of thing until it restarts) or Deny.

Either way you can add a note, and the agent reads it with your answer: "No, open a pull request instead." The first answer counts; everyone else who could answer sees who did.

Under each request, the assistant says what it means in plain words, how risky it is and why, quotes the lines of your instruction that decide it, and suggests an answer. It only suggests: nothing happens until you press a button. It reads the agent's words as a request to judge, never as orders to follow.

If nobody answers

A request waits 30 minutes, or what its rule's answerWithin says (1 to 1,440 minutes). Then a permission is denied, and a question is left to the agent: it picks the safest option and says which. Either way the agent is told nobody answered.

deployments_rules_create
{
  "orgId": "acme", "name": "Support agents", "platform": "agents-box",
  "selector": { "project": "prj_…" },
  "controls": { "answerWithin": 60 }
}

An agent's conversation

Each agent on the Deployments page has a Conversation: what it said and did, a line at a time, its requests and their answers, and what people wrote to it. From there you can:

  • Write to it. It reads your message at once (or at its next step) and goes on with everything it knew.
  • Interrupt it: it stops what it is doing now and waits for you.
  • Restart it from the beginning.
  • Summarize: the assistant says in a few lines what it has done, what it waits on and what went wrong.

Who answers

The people who answer for an agent are whoever made its rule, whoever deployed it, whoever runs it on their machine, and the organization's owners and admins. They are the ones told, and the only ones who may answer, write to it or restart it.

Setting it up

Run your agents with instruction fleet. For Claude Code, give it its task as claude -p "…": the fleet then becomes Claude Code's host, so its permission requests and its questions come to you, and your messages go straight to it.

Shell
# Claude Code, with the fleet as its host: its questions and permission requests come to you
instruction fleet --platform laptop --org acme -- claude -p "Work through today's support queue."

# the plain process instead (its messages still reach it through the hook)
instruction fleet --platform laptop --org acme --no-converse -- claude -p "…"

Other agents (Codex, your own scripts) get your messages at their next prompt or tool use, through the hook the fleet sets up, and can ask with the tools below.

What leaves the machine

  • A request carries what the agent would do. Before it leaves, anything that looks like a secret (an API key, a token, a password) is replaced with •••, and long inputs are cut.
  • A conversation keeps its last 500 lines, for 30 days.
  • The assistant's reading is made only when someone opens a request, and counts against your assistant allowance. It sends the request, your instruction and the agent's last lines to OpenAI to be read (not kept). If your organization turned the assistant off, there is no reading, and everything else works the same.

For your own runners

Everything here is an MCP tool on instruction.md's server, for agentd, your own runner, or an agent itself:

Tools
deployments_asks_create    ask the people who answer for the agent (a question, or a permission)
deployments_asks_get       read its answer
deployments_asks_list      what your agents wait on
deployments_asks_answer    allow, allow_run or deny; or each question's answer; with a note
deployments_messages_send  words to the agent, or interrupt / restart
deployments_messages_list  the conversation (a runner's take: what waits for its agent)