Agent tools

The agent works by calling tools. Each call is a line in the chat that starts with what it did, such as Read, Edited or Ran; open a line for its details. Back-to-back reads and searches fold into one Explored line, back-to-back edits of one file fold into one line with their count (×3) that opens to each diff in order, and once a turn ends its work folds into Worked for. A file outside the chat's folder, such as one in a worktree a subagent works in, is named from its own checkout's folder; hover it for the full path. Connectors you add in Settings › Connectors bring their own tools, and each shows in the chat by its name.

A model whose provider runs its own web search answers with the pages it cites: the answer reads as one message, and a Sources row under it names each site. Click a site to open the page; past five sites, more opens the rest. Each search the provider ran is a work step like the agent's own: Searched the web with its query and how many results came back, opening to each page's title and link, and while it runs an agent's line says Searching the web. A search the model asked for that the provider never ran (you stopped the turn, or a message of yours joined before it ran) shows no step and counts in no Explored line. A subagent's own chat shows its searches the same way.

Tools

Tools in an agent's chats

A Lookout agent's chats add these, so the agent can work with your other agents:

Driving a browser

Every chat and every subagent has Browser: it drives web pages in Lookout's own headless Chrome, so the agent can check a local dev server, click through a sign-up, fill a form or read a page that needs a click to show what you asked for. The agent reads each page as text, one line per element with a short reference it acts on, and each call runs a batch of steps (navigate, click, fill, type, key, scroll, wait, screenshot and more) and comes back with what changed on the page. It asks for a screenshot only when it needs to see the page. It can set the page's size to check a layout at several widths in one call, and take a screenshot of the whole page, not just what is in view. After a step that submits, pays or deletes something, it looks at the page before going on.

• Nothing opens a window, and your own Chrome is never touched: Lookout starts its own Chrome in the background the first time a chat needs it, and closes it after 15 minutes unused.
• The browser has full access in every mode: local servers, your network, and every site. The agents in one sidebar section share a profile, and every other chat shares the default one, so a site signed in to once stays signed in for the next chat there. Deleting a section removes its profile and those sign-ins. Each chat and each subagent works in tabs of its own.
• A password an agent needs comes from its site logins: the browser types it into the site's own password field, and the agent never sees it. While a page holds that password, the agent's scripts on it wait, and its screenshots show the field as dots.
• It needs Google Chrome or Chromium installed. Without one, a Browser call answers with the line that says how to install it.
• To turn it off for every chat, switch off Browser in Settings › Plugins. Chats get the change with their next message; a chat already running is told the tool is gone.
• While a chat has a browser open, its side pane has a Browser tab: the page live with the agent's pointer and tabs, on Watching. Take over gives you the mouse and keyboard while the agent's steps wait; Hand back returns it. When the agent needs you (a code sent to your phone, a page only a person can do), the tab opens by itself in control with its reason, and I'm done lets it go on. Only this Mac's own window can watch or drive.

In the chat, a Browser call reads as what it did, such as Clicked Continuă, or Opened and the page's title, with a small picture of where it acted. Open it for its steps, the page as the call left it with a ring where the agent clicked, what changed on the page, what it read, and the request and the text the agent read under Raw. Calls in a row fold into one Browsed line with the site, its steps and pages.

Reading PDFs

Read opens a PDF as its text, page by page, each page under a marker such as --- page 3 of 34 ---. Lookout extracts the text and draws the pages itself, the same way on a Mac and on Linux, with nothing to install.

• The agent can ask for one page or a range with pages, such as "3" or "1-5", up to 20 pages a call. A range that runs past the last page returns the pages that exist and names the page count; a range longer than 20 pages returns its first 20 and the pages value that reads on. Only a range that starts past the last page fails, with a line that names the page count.
• Without pages, a read starts at page 1 and returns the pages that fit in one read: up to 20 pages and Read's usual 50,000 characters. When pages remain, the result ends with the page count and the pages value that reads on.
• A page with no text, such as a scanned page, says no text layer in its marker. When the chat's model can view images, Read draws the page and sends it to the agent as an image, so the agent reads the scan itself; a page that draws blank says so instead. A read draws up to 10 pages, and when more remain the result names the pages value that reads on.
• A model that can't view images gets the marker and a line saying the page has no text layer.
• Scans from black-and-white office scanners (JBIG2 and CCITT fax) and JPEG 2000 scans draw like any other. A page whose scanned image is damaged says so in its marker.
• A password-protected or damaged PDF fails with a one-line reason.

Tools in each mode

Every mode has the same tools with the same access, and no tool is refused because of the mode: the mode is an instruction the agent follows. In Ask it answers without changing files, and in Agent and Multitask it changes what the task needs.

• A subagent started in Ask works in Ask; otherwise it works as Agent. A subagent can't start subagents of its own or save memories.

Watching a command

For a long wait on output, such as a CI run, a deploy log or a landing, the agent can run a command with a watch and end its turn. Each line the command prints that matches the watch's pattern wakes the chat with that line; lines that come together arrive as one. Its exit, with its exit code, and its deadline (an hour unless the agent sets one, eight hours at most) wake the chat too, so a command that crashed never looks quiet. A turn a watch starts may end with no reply when nothing in it is for you.

• While a watch runs, the chat's status row says Watching and names the command; open it for the pattern and the deadline. lookout sessions lists the chat as watching.
• Your next message or Stop ends the chat's watches and stops their commands. The agent can end one itself.
• A command that prints matching lines faster than about two a second for a minute is stopped, and the agent is told why.
• A watch keeps running across an update or a crash, like any background command.

Running commands

While a chat has commands running, its status row says so: Running and the command's description for one, 3 commands running for more. Click it for the list. Each row shows the command's description (or the command), how long it has run, the subagent that started it, and a watched command's pattern and deadline.

• Open output opens the command's terminal file, which holds everything it printed so far.
• A command piped into tail, head or grep keeps only what the pipe passes, in the chat and in its terminal file. The agent is told to leave a slow command's output whole: the chat shows its start and end, and Open output all of it.
• Stop ends that command alone, with everything it started. The row reads Stopped until it has exited. The agent is told the command was stopped by you; an idle chat starts a turn to hear it, as when a command ends on its own. Stopping a watched command ends its watch.
• The chat's Stop ends its turn but leaves commands it sent to the background running; this list is how you stop one of those.
• Commands that keep running across an update or a crash are listed and can be stopped the same way.
• A command another program pauses (a memory guard, a debugger) has not ended: its terminal file says stopped and since when. An agent waiting on it hears within about 30 seconds what was paused, how much memory it holds and what the pausing program wrote, and an idle chat is told once if it stays paused for 10 minutes. A pause that ends sooner tells nobody.

Calls that run at once

When the agent makes several calls in one step, back-to-back Read, Grep, Glob, Ls, Fetch, WebSearch and Task calls run side by side, up to 10 at once and at most 3 of them subagents. Every other call runs on its own, in order.