Obvious/Help Center

How Obvious works on complex tasks

Published February 28, 2026 · Last updated March 5, 2026 · 6 min read

When you give Obvious a complex request — research three competitors, analyze a dataset from multiple angles, build a report that requires independent investigations — the agent doesn't try to do everything sequentially in a single conversation. It breaks the work into pieces and runs them in parallel using sub-threads.

This is how Obvious handles tasks that would overwhelm a single conversation thread. Understanding how it works helps you give better instructions, monitor progress, and get better results.

What sub-threads are

A sub-thread is a focused conversation the main agent spawns to handle a specific piece of work. Each sub-thread gets its own context, its own agent, and a clear objective. It runs independently, reports back when it's done, and the main thread synthesizes the results.

Think of it as delegation. You give the main agent a big task. The main agent identifies the parts that can run independently, creates a sub-thread for each one, and coordinates the results. The sub-threads work simultaneously — a task that would take 30 minutes sequentially might take 10 minutes with parallel execution.

Sub-threads share the same project workspace. They can create artifacts, write to sheets, access files, and use the same integrations as the main thread. What they don't share is conversation context — each sub-thread starts fresh with its own instructions and objective.

How it looks in practice

When the agent spawns sub-threads, you see them appear in the thread list on the left side of the chat panel. Each thread shows a descriptive name, a status indicator, and its relationship to the parent thread.

Status indicators use colored dots to show what's happening:

  • Green (pulsing) — the thread is actively working
  • Green (solid) — the thread completed successfully
  • Red — the thread encountered a failure
  • Yellow — the thread needs input from you or the parent thread
  • Gray — the thread is idle or archived

Click into any sub-thread to see what it's doing — the full conversation, the artifacts it's creating, and the tools it's using. This transparency lets you monitor progress without interrupting the work.

Thread objectives

Every sub-thread is spawned with a stated objective — a clear description of what it needs to accomplish. The objective serves as the thread's success criteria. When the sub-thread finishes, it reports one of three statuses:

Success — the objective was met. The thread includes a summary of what it accomplished and any structured results that the parent thread can use.

Failure — the objective couldn't be met. The thread explains what went wrong. The parent thread can retry, adjust the approach, or escalate to you.

Input required — the thread hit a point where it needs additional information to proceed. You or the parent thread can provide that input, and the sub-thread continues from where it stopped.

When a task hits its step limit

Obvious agents work through complex tasks step by step. For very long tasks, an agent may hit its step limit before finishing.

When that happens, the agent doesn't fail silently. It pauses, explains what it was doing, and waits for you to tell it to continue. You'll see a message like "I hit my step limit. Send a follow-up to keep going." Reply in the thread, and the agent picks up where it left off.

This is different from an agent that's frozen or stuck (which shouldn't respond to messages). A paused agent is waiting for input — it will continue as soon as you reply.

Batch execution

For tasks that naturally split into many parallel pieces — researching 10 competitors, processing 50 documents, analyzing data across 8 regions — the agent can spawn sub-threads in batches. Batch mode groups related sub-threads together and sends a single summary notification to the parent thread when the entire batch completes, rather than notifying after each individual thread.

This keeps the main conversation clean. Instead of receiving 10 separate completion messages, you get one consolidated result with findings from all sub-threads.

Monitoring and managing threads

The thread list shows all active and completed threads in your project. Threads spawned by the main conversation appear as children, visually nested or labeled to show their parent relationship.

Each thread in the list shows its current status, which you can filter and group. The multi-thread view organizes threads into categories: In Progress, Needs Input, Queued, Failed, Completed, and Cancelled.

You can interact with any thread directly. Click into it to read the conversation, send a message to provide guidance, or ask a follow-up question. If a thread is heading in the wrong direction, the parent agent can redirect it by sending new instructions.

Completed threads can be archived to keep your thread list clean. Archiving is reversible — the thread and its conversation history are preserved and can be restored later. Note that archived threads can't receive new messages. To send a message to an archived thread, unarchive it first.

When threads get created

The agent creates sub-threads when it identifies work that benefits from parallelism or focused context. Common triggers include:

  • Research tasks with multiple independent subjects ("research these five companies")
  • Analysis tasks that span different dimensions ("analyze revenue by region, by product, and by customer segment")
  • Content production with independent sections ("write the executive summary, the methodology, and the findings")
  • Data processing with independent sources ("import and clean these three CSVs")

The agent also uses sub-threads for tasks that would bloat the main conversation's context. Heavy exploration — reading many files, crawling documentation, investigating an unfamiliar codebase — benefits from running in a sub-thread that returns a concise summary, keeping the main thread focused.

You don't need to ask for sub-threads explicitly. The agent decides when parallel execution would produce better results and handles the delegation automatically. If you'd prefer the agent to work sequentially, say so, and it will stay in a single thread.

Tips for complex tasks

Give clear, specific objectives. "Research competitor X" is fine. "Research competitor X's pricing model, target market, and recent product launches, then create a summary document" is better. The more specific your request, the more effectively the agent delegates.

Let the agent plan. For tasks with five or more steps, the agent may propose a structured plan before executing. Review it, adjust if needed, and approve. This alignment step prevents wasted work on complex workflows.

Monitor actively during important tasks. Click into sub-threads to verify they're on track, especially for time-sensitive or high-stakes work. You can course-correct early rather than discovering issues after all threads complete.

If an agent pauses, just reply. A step-limit pause isn't a failure — it's the agent waiting for your go-ahead. Reply with "continue" or anything that tells it to keep going.

Next steps

Was this helpful?