Agents Overview

The Obvious agent is an AI that works directly inside your project — it can see your artifacts, and take action on both. You can also drag files into the chat (CSV, Excel, PDF, images) to give the agent new material to work with. Between what's already in your project and what you bring in, the agent has the context it needs to help.

What the agent actually does

The agent lives in the chat panel alongside your project. You talk to it in natural language — describing what you need, asking questions, giving feedback — and it acts directly on the artifacts in your workspace.

Here's a representative sample of what it can handle:

• Create and edit artifacts — Build workbooks, configure sheets, write and edit documents, create views, generate slide decks and folios.
• Analyze data — Run SQL queries against your sheets, identify patterns, summarize datasets, flag data quality issues, generate charts from sheet data.
• Research — Search the web, synthesize findings into documents or workbooks, pull in external data from APIs or connected services.
• Connect to tools — Read and send messages in Slack, draft and reply to email, pull data from a connected CRM, interact with your calendar.
• Write and run code — Data transformations, custom scripts, hosted web applications running directly in the workspace.
• Automate workflows — Build tasks that run on a schedule or in response to an event, then execute them without you present.

Context and memory

The agent maintains context within a conversation — it remembers what you've discussed and what you've built in the current thread. Across sessions, it has a persistent memory system that stores key facts and preferences so you don't have to re-establish important context every time.

User-level memory captures things like how you prefer to work, what formatting you like in documents, and recurring context about your role and goals. Project-level memory captures decisions, data schemas, and work-in-progress context from earlier sessions.

Memory is selective, not exhaustive. The agent stores what it identifies as important — not every detail of every conversation. If something critical needs to carry forward, it helps to tell the agent explicitly: "Remember that we decided to use quarterly cohorts for this analysis."

Modes

The agent runs in different modes that change how it approaches work. Switch modes using the selector at the bottom-right of the chat input.

Agent is the general-purpose mode. It researches, writes, codes, and analyzes across any surface in your workspace, working in parallel where the task allows. Most work happens here.

Autobuild is built specifically for shipping code — it writes specs, plans PRs, monitors CI, and drives changes to merge. Use it when the deliverable is a code change headed to a pull request.

Draft researches deeply, then writes up a grounded blueprint — a structured document, not working code. Use it when you want a well-researched plan or spec worked out before anything gets built.

If you or your workspace have built custom agents — saved configurations with their own instructions, tools, and behavior — they appear directly in the same picker, listed by name below the three built-in modes: agents you own under Your agents, agents shared with you under Shared with you.

Separately from mode selection, a Normal / Max toggle — the lightning-bolt icon next to the mode picker — controls how much reasoning depth the agent applies. Max mode uses 2-3x the credits of Normal mode for harder problems that benefit from deeper thinking. This replaces the previous Fast, Deep Work, and Analyst mode options — reasoning depth is now a simple two-state toggle rather than a separate mode choice.

Sub-threads and objectives

For complex work — research that spans multiple topics, analyses that require running several independent queries, workflows that touch different parts of your project — the agent can spawn sub-threads.

A sub-thread is a focused conversation that handles a specific piece of the larger work. The parent thread coordinates; sub-threads execute. When all sub-threads complete, the parent synthesizes the results.

You can also give a sub-thread an objective: a specific outcome it's responsible for delivering. Objectives put the sub-thread into a structured mode where it must explicitly report success or failure before the work is considered done. This is the mechanism behind parallelism — the agent can run multiple independent threads simultaneously, each with its own objective, then consolidate.

You don't have to configure any of this manually. When you ask the agent to do something complex, it'll make the call. You can also explicitly ask: "run those three analyses in parallel and report back."

When to use the agent vs. doing things manually

The agent isn't the right tool for everything, and recognizing when to skip it saves time.

Use the agent when: the task involves judgment, transformation, or synthesis. Cleaning messy imported data. Writing the first draft of a report. Building a workbook schema from a description. Analyzing which accounts are at risk based on activity patterns. Researching a topic and surfacing what's relevant. These are tasks where a blank canvas and natural language are genuinely faster than clicking through menus.

Do it manually when: the task is simple and discrete. Rename a field. Add a row. Change a cell value. Fix a typo in a document. The UI is faster for these — sending a message and waiting for a response has overhead that clicking doesn't.

A useful rule: if you could do it in two clicks, do it in two clicks. If you'd spend more than a minute thinking about where those two clicks are, ask the agent.