Obvious/Help Center

Thread Objectives & Orchestration

Published February 27, 2026 · Last updated March 5, 2026 · 4 min read

When you ask Obvious to do something complex — say, research five competitors and write a comparison report — the agent doesn't try to cram everything into a single conversation. It breaks the work into pieces, hands each piece to a focused sub-thread, and coordinates the results. This is objective-based orchestration, and it's how Obvious handles work that would otherwise be too big, too slow, or too messy for one agent to manage alone.

What's an Objective?

An objective is a contract between a parent thread and a sub-thread. It says: here's what you need to accomplish, here's how to tell me you're done, and here's the shape of the answer I expect back.

Think of it like delegating to a colleague. You don't hand someone a vague "look into this." You say: "Research Company X's pricing, write up a one-page summary, and send it back by end of day." That's an objective — a defined task with a clear finish line.

When a parent thread spawns a sub-thread with an objective, three things happen:

  1. The sub-thread receives the objective as its guiding purpose.
  2. The sub-thread enters objective mode — it knows it must report a status before it's done.
  3. The parent thread moves on to other work (or waits) until it hears back.

The objective can also include a response schema — a specific structure the result must follow. If the parent needs a list of findings with titles and summaries, the schema enforces that. The sub-thread can't report success with a mismatched answer.

How Sub-Threads Report Back

A sub-thread in objective mode has four ways to signal its status:

Success. The work is done. The sub-thread sends back a summary and structured results, validated against any defined response schema. Mismatched results are rejected.

Failure. The sub-thread tried but couldn't complete the objective, perhaps due to an unreachable API or missing data. It reports what went wrong, allowing the parent to decide on next steps.

Input required. The sub-thread needs more information to continue. It pauses, sends a description of what's needed, and the parent can provide context to restart it.

Pending. After receiving requested input, the sub-thread resets to pending and resumes work. This signals a "back to work" state, not completion.

Once a sub-thread reports success, failure, or input-required, the parent thread is notified automatically. The notification arrives as a message in the parent thread with the sub-thread's summary and results, and the parent continues its work.

Why Not Just Do It All in One Thread?

Context. A single agent working through a ten-step project accumulates every search result, every dead end, every intermediate calculation in its working memory. By step seven, it's wading through noise from steps one through three.

Sub-threads start clean. Each one gets a focused prompt, works within a narrow scope, and returns a distilled result. The parent thread receives a concise summary — not the entire trail of exploration that produced it.

Batch Orchestration

When the parent spawns multiple sub-threads for related work, it can group them into a batch. Batches change how completion is reported.

Without a batch, each sub-thread notifies the parent individually the moment it finishes. The parent might get five separate "I'm done" notifications, one at a time, and has to track which ones are still outstanding.

With a batch, the parent tells Obvious: "Don't notify me until all of these are done." The sub-threads still work independently, but the parent receives a single consolidated notification once the entire batch completes. That notification includes every sub-thread's status, summary, and results in one place.

Batches track completion state automatically — how many sub-threads have succeeded, how many failed, and how many still need input. If some sub-threads succeed and others fail, the batch reports a partial result so the parent can decide how to proceed with the work that did complete.

What You See

Most of this happens behind the scenes. When an agent decides to break work into sub-threads, you'll see it mention what it's delegating and why. The sub-threads appear in your project's thread list, and you can open any of them to see what they're working on.

When the work completes, the parent thread synthesizes the results into whatever you asked for — a document, a workbook, an analysis. The sub-threads get archived once their value has been incorporated.

Was this helpful?