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.
| Tool | In the chat | What it does |
|---|
GenerateImage | Generated image | |
Read | Read | Reads a file, or part of a long one. A PDF reads as its text, page by page, and a scanned page as an image. |
Write | Wrote | Creates a file, or replaces one the agent has read in full and that hasn't changed since. |
StrReplace | Edited | Replaces exact text in a file. |
Delete | Deleted | Deletes a file, or a whole folder. Never the workspace folder itself. |
Ls | Listed | Lists a folder's entries with their sizes. |
Glob | Searched files | Finds files by name pattern, newest first, skipping hidden and ignored paths. |
Grep | Grepped | Searches file contents with a regular expression, skipping ignored files and hidden folders. |
Shell | Ran | Runs a command in your shell, starting in the workspace. A command still running after its wait moves to the background. |
AwaitShell | Waited on | Waits for a background command to finish or print a line, or stops one this chat started. |
TodoWrite | Updated to-dos | Keeps the chat's to-do list for multi-step work. |
AskQuestion | Asked | Asks you multiple-choice questions and waits for your answers. |
AskParent | Asked | |
Fetch | Fetched | Reads a web page as text, local servers included. A public page's redirect never reaches a private address. |
WebSearch | Searched the web | Searches the web. A model whose provider has search of its own searches that way instead; one whose provider has none can't search the web. |
Task | Completed task | Starts a subagent on a self-contained task, in the background if asked, or continues an earlier one with its whole context. |
SaveMemory | Saved memory | Saves or deletes a memory, for this project or for you. A memory holding a credential is refused. |
Tools in an agent's chats
A Lookout agent's chats add these, so the agent can work with your other agents:
| Tool | In the chat | What it does |
|---|
Agents | Agents | Lists your Lookout agents and what each is doing, or saves its own profile when you ask. |
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, never while a download is still running.
- A file the agent downloads is saved in its browser session's own folder. The agent sees it start, its progress in each call after, and where it was saved, and it can wait for it to land. If it lands after the agent has moved on, or after the chat went quiet, the chat is told then, as it is when a command it left running in the background ends.
- 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. Chrome keeps no history or form data in these profiles; its web cache and its download records (a download's address and the address of the page it came from) remain.
- A password an agent needs comes from its site logins: the browser types the username and the password into the site's own sign-in form, and the agent never sees the password. A login that keeps its 2FA key also gets its code typed, never shown to the agent, and waits for your click each time. While a page holds that password or code, the agent's scripts on it wait, and its screenshots show the field as dots.
- A secret a page shows reads as
[secret] to the agent: a value beside a label that names it (Client secret: and the value on one line, a Client Secret column, a read-only API key field, a term and its definition, the codes under Recovery codes), a literal after a secret's name in code (DB_PASSWORD=, --token, a bearer header), a key in a provider's own format, a signed token or a private key, and the value of an address's secret parameter (a URL's signature, say). Only the value is hidden, never its label, and a screenshot draws it as dots where it stands. Words, masks, dates, counts and references stay readable, so Password: required, Password: (optional), Input tokens: 12,345,678, ******** and process.env.DB_PASSWORD read as written, as do commit ids, checksums, ids and what you or the agent type into a field or a code editor. A value hidden by its label stays hidden in everything the browser returns for the rest of that session; a screenshot that can't cover one, or whose page kept showing new hidden values while it was taken, is not handed over. To keep such a value, the agent saves it as one of its secrets without reading it, once you allow it on a card. To type one of its secrets into a field, it names the secret, and the first time on each site a card asks you. A step the agent marks quiet comes back with its outcome, the page's address and its title, and no text from the page.
- 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, and opens the page large over the app, laid out as a desktop window at the size of the view: at least 1024 pixels wide, shown smaller in a window too small for that. Its bar, like the tab's, has Back, Forward and Reload (Stop while the page loads, with a thin line running under the bar), the page's address and what the agent asked. While you drive you can type an address there, or words to search the web for; pointing at the address shows Open outside Lookout, which opens the page in your own browser. ⌘L goes to the address and ⌘R reloads, even while the page has the keyboard, and ⇧Esc takes the keyboard back out of the page. Open in the pane moves the page into the tab while you keep driving, and the app opens it there next time until Open large brings it back; in the tab the page lays out at the tab's size as you resize the window, or at its own width, shown smaller, when it is built wider than the tab and cannot scroll sideways. Hand back puts the page away and returns it at the agent's own size, and the agent looks again before it acts. While you drive, a page's dropdown opens as a menu on its field, date and time fields take typing, a page's alert, confirm or prompt waits over the page for your answer, and a file field opens the file picker on your Mac. What you copy in the page lands on your Mac's clipboard, and ⌘V pastes from it; a copy counts only right after your own click or key, and the agent never sees it. When the agent needs you (a code sent to your phone, a page only a person can do), the tab opens by itself with its reason, and its row in the chat reads Waiting for you with Take over, then You're driving; Hand back lets it go on, and the row reads Handed back with the page it ended on and the time. Closing the tab gives control back without ending the wait. When it asks in a turn you didn't start (a routine, a teammate's message), its chat waits on you in the sidebar, the browser stays open for up to 12 hours, and the agent picks the work up again once you press Hand back. An update waits for a handoff while you drive, or for up to 30 minutes after the agent asked or you last drove; a restart closes the browser, the row reads The browser closed before you handed back, and the agent is told, so it goes on without you or asks again. 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.
An image reads as at most 2000 pixels on a side, whatever its format. A long image, such as a full-page screenshot at
least twice as tall as it is wide, reads in parts top to bottom (or left to right), each part naming the slice of the
page it shows, instead of one thumbnail too small to read. A read shows up to 10 parts, and when more remain the result
names the pages value that reads on.
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, a terminal glyph under the message box says so: its tooltip reads 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 but never their commands, and so does a message from the chat's lead or another chat: each keeps running as a background command of the chat, in the list below, until the watch's deadline, when it is stopped, even across a restart. The agent is told whose message ended it, that it still runs, until when, and how to stop it sooner. A message from a script or an MCP client that doesn't lead the chat leaves its watches running: the agent reads the message, and a watch's later wake says it was armed before that message. The agent can end a watch with its command itself; so do Stop on the command's row and archiving the chat.
- 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 a quit, an update, a crash or a service restart, like any background command: the next start keeps matching its lines. One whose command a restart of the machine ended wakes the chat once at the next start.
- A subagent has no turn a watch could wake, so its watch waits in the call instead: it returns with the first matching lines or the command's exit, and stops the command at the watch's deadline.
Running commands
While a chat has commands running, a terminal glyph under the message box says so, its tooltip 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 a quit, 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: every subagent at once, and up to 10 of the other calls at once. Every other call runs on its own, in order.