Chat

webagents opens a chat with the agent in the current folder: its AGENT.md, or the only AGENT-<name>.md. With no agent file, it opens the built-in assistant, which can read and edit the files in the folder and call web APIs (the filesystem and rest skills), and says how to make an agent of your own: /agent new <name>. In the chat you are the agent's owner, so owner-only tools are yours to use. The chat looks and works the same in the TypeScript and Python CLIs: the same commands in the same words, the same keys, the same conversation files and the same history, so a conversation started in one can be continued in the other.

The agent runs on its own model:, with your key for that provider. Without the key, and signed in with webagents login, it runs the same model through Robutler, paid from your credits. An agent with no model: uses any provider you have a key for, or Robutler's default model when you have none. When the file lists fallback_models, the chat moves to the next one when a model does not answer, and says so. See Models.

When there is neither a key nor a sign-in, the chat asks before the first message: sign in in the browser, type a key (kept for next time, with input hidden), or carry on without a model. /login, /keys and /model do the same later, without leaving the chat.

Type / for the menu: ↑ ↓ choose, tab completes, enter runs. /help <command> shows a command's forms. The menu opens above the input box, over the last lines of the conversation, and puts them back when it closes. At the top of a cleared screen, where there is nothing above the box to open over, it opens under the box. /help lists the commands in the five groups below.

The menu searches as you type. It finds a command by its name or, from two letters on, by a word of what it does: /sign finds /login and /logout. After a command it lists what that command takes, and what you type narrows the list by name or by the words in each row, several words at once and in any order: /resume budget sheet, /model 4.1, /help sign in. A word matches the start of a word, so bud finds "budget".

A command takes at most one word naming what to do (/mcp add, /resume delete, /keys remove), then its arguments; there is never a second level.

A turn may run 50 tool rounds unless /rounds, --max-tool-rounds or the agent file's max_tool_rounds says otherwise. At the limit the agent makes one last call with tools off and answers from what it gathered, and the chat asks Used 50 tool rounds. Keep going? [Y/n]: yes goes on with a fresh budget, no ends the turn. A turn that makes the same tool call three times in a row with the same arguments, and gets the same result each time, stops the same way, and the chat says which tool it repeated; any other call in between (an edit, another command) or a different result starts that count over, so an edit-and-rerun cycle is not a loop. -p, serve, the daemon and ACP never ask: they end with the answer and the reason (tool_round_limit or tool_loop).

A command that fails says why and the chat goes on. A command given arguments it does not take shows its usage and does nothing. A mistyped name gets a "did you mean", and /edit points to /agent edit. /keys unset NAME still works as /keys remove NAME.

/agent new, /agent edit, /skills add and /skills remove, /model --save and /publish change a file or something on Robutler, so they follow the same rules:

/agent new writes into the chat's folder, never into your home folder, with the provider the chat is running on, so the new agent answers at once. /skills add with a source (owner/repo, a git URL or a folder) lists every file it would install and asks; the chat never accepts --yes. /model only offers models the agent's own model skill can run: an agent that names the openai skill runs openai/ models until you add another provider's skill.

When the file changes outside the chat, the chat notices before your next message and says so once; /reload shows what changed and asks before it uses a new access:, sandbox:, cron:, skill list or mcp.json. The chat never reloads unasked.

/publish creates the agent on Robutler, or updates the one this folder is linked to. Before it updates a linked agent it asks Update <agent> on <host> from <file>? [y/N]; from a pipe it never updates. /publish --dry-run shows the method, the route and the body.

Stopping a reply stops the command it was running too, with everything that command started, and the chat says Interrupted. A command never reads what you type into the chat: its input is empty.

After /resume , /rewind , /agent , /model , /skills , /help , /keys , /cron , /memory or /mcp , the menu stays open and offers what the command takes: this folder's earlier conversations and snapshots, its agents, the models the agent can switch to, the forms (delete, new, edit, add, remove, run, forget, list), the skills an agent file can name, provider key names, the agent's schedules, your notes, the MCP servers other apps use and, after /mcp remove, this agent's own.

enter on a row that completes the command runs it: a conversation to continue, a snapshot to go back to, a model or an agent to switch to, a command to explain, a key to set, a schedule to run, a note to forget. None of those changes a file or what is stored without asking you first. enter on any other row puts it in the box and the line goes on: a form, a skill (several may follow), and the rows of /mcp add, /mcp remove and /keys remove, which act without asking, so a second enter sends them. tab always puts the row in the box. /resume and /rewind chosen in the menu open their list rather than printing it.

The lines you type are kept in history under your profile folder (~/.webagents/history, or ~/.webagents-<name>/history under --profile), readable only by you (folder 0700, file 0600), the last 1,000 of them. Both CLIs read and write the same file, so ↑ finds a line typed in either.

Each line is kept with the folder it was typed in, and a chat offers only the lines typed in its own folder: ↑ and the grey suggestion never bring back another project's prompts. A line with no folder recorded is not offered. A recalled line that starts with / does not open the command menu, so ↑ and ↓ keep walking the history; edit the line or move the cursor and the menu opens.

Every reply is saved as it arrives. A chat starts a new conversation; when the last one here was used in the past day, the chat says so under the banner (Last conversation here 2h ago (14 messages): /resume 1 continues it.) and waits for you. webagents -c opens the chat already in it.

/resume opens this folder's earlier conversations with the agent in the menu, newest first, each with when it was last used, how many messages it has and how it began. Type to narrow the list by what was said (/resume budget), ↑ ↓ to choose, enter to continue one; the chat shows its last few exchanges first. /resume 2 continues the second one directly, and webagents -r 2 does the same from the shell. /resume delete chooses one to delete the same way, and asks first. /new starts over; the old conversation stays in the list. Outside the chat, webagents conversations lists, deletes and prunes them.

Conversations are kept under your profile, in ~/.webagents/sessions/<folder>/<agent>/, never in the project, so nothing is left in a folder you chat in. The files are readable only by you. When the agent file lists - session: {backend: robutler} under skills:, they are also kept on Robutler, and /resume lists both; deleting one here leaves its copy on Robutler. /undo and /rewind take back what an agent changed in the folder. See Conversations.

A conversation grows until it no longer fits the model's context. The chat keeps it within bounds by compacting it: first the long outputs of old tool calls are cleared (the call stays, with a one-line note of what it returned), and when that is not enough, everything before the latest exchanges becomes one summary made by the agent's own model. By default this happens before a message would take the conversation past 80% of the model's context, and the chat says so:

The agent file's compaction: block changes the defaults, and auto: false turns the automatic part off. See Context compaction.

After each reply the footer shows the conversation's tokens and, when it is known, what they cost in credits: 2.5k tokens, ~0.0006 credits. On Robutler's models the chat shows the cost the platform reports with a reply, and tokens alone when it reports none. With your own provider key it is an estimate from the provider's list price, which is why it carries a ~ (cache reads and long-context tiers are not counted). A model the price table does not know, and a local Ollama model, show tokens alone. /status shows the conversation's totals, and the line you see on leaving shows this chat's.

@path/to/file in a message includes that file's contents:

A word after @ that is not a file in the folder is left as typed.

When the input is not a terminal, the chat reads one line at a time and prints plain text, so a script can drive it:

Every question answers no from a pipe, and the commands that change a file refuse. For one answer and nothing else, use webagents -p "...", with --output-format json or stream-json for machine-readable output.