Inside Orbit's Deep Research

Orbit's deep research engine is an iterate-research loop: plan, classify, search, extract, merge, check coverage, and repeat — typically 8–14 rounds across 65+ sources — before composing a final report. Here's what happens inside the loop, and what you get at the end.

In plain English

Orbit's deep research is a tireless analyst: it breaks your question into parts, searches, reads, merges what it learned into a growing draft, checks what's still missing, and repeats — 8 to 14 rounds across more than 65 sources. It's the research version of "measure twice, cut once."

Most of us research like we assemble flat-pack furniture: start, panic, re-read, improvise. The engine skips the panic.

The loop, step by step

Every deep research run follows the same structure:

1. Plan — the engine decomposes your question into sub-questions.
2. Classify — it decides which sub-questions need fresh searches.
3. Generate queries — targeted queries are produced for each gap.
4. Search — multiple engines run in parallel, including premium answer providers.
5. Extract — promising pages are pulled and cleaned into findings.
6. Delta-merge — new findings merge into a growing research draft.
7. Coverage check — the engine marks questions answered and re-targets the rest.
8. Repeat — the loop iterates until coverage converges.

That final loop is the core: the draft isn't written at the end of a single search, it's rebuilt and enriched on every round. In Orbit's deep mode, that means 8–14 rounds across 65+ sources.

Coverage that only grows

One subtle design decision: coverage never regresses. Each round rewrites the research draft, so a naive merge could flip a sub-question from answered to unanswered and back, causing flicker and false signals.

Orbit's merge logic unions previously answered items with new ones. The coverage checklist you see in the UI is monotonic — it only grows as rounds succeed. When the run ends, you see exactly which sub-questions are answered and which remain open, honestly.

Model routing inside the loop

Research quality is a model-selection problem as much as a search problem. Orbit routes across 150+ models, assigning roles:

• Planning and query generation — strong reasoning models that resolve pronouns against your conversation history and the earlier turns.
• Search and extraction — fast, cost-efficient models that handle the mechanical rounds.
• Final report — a powerful reasoning model that synthesizes findings into the finished write-up.

Fast mode uses lighter models for straightforward questions; deep mode spends on the reasoning-heavy parts. The result is a quality-versus-cost curve you can pick from before the run starts.

Timeouts that match the job

Research takes time, and timeouts must reflect that. Orbit's deep research step runs under a much longer budget than a normal chat turn — chat turns get a 10-minute timeout, while a full research pass is allowed to run for well over an hour before the report is composed.

That's a deliberate design choice: a thorough synthesis shouldn't be silently killed mid-merge because it hit a chat-sized timer.

What you actually receive

When the loop converges, the output is more than a chat message:

• A final report written to the project as a durable artifact.
• An HTML report with the sources' images and links, so the deliverable is shareable.
• A coverage checklist showing answered and unanswered sub-questions.
• A chat brief with the summary you can read immediately.
• A Dig deeper action that re-runs the engine on a follow-up question, using the prior report as context.

And because research lives inside the workspace, the report and sources stay linked to the project — ready to inform the next build.

Why it's built this way

Deep research fails when it fakes coverage, ignores prior context, or runs without budgets. Orbit's engine addresses all three: monotonic coverage reporting, conversation-aware planning, and strict round and timeout budgets. It's designed to be a research tool you can hand a hard question and actually rely on.

Try it and compare

Hand the same hard question to a plain chatbot and to Orbit's deep mode. Compare the number of sources each one actually uses, the coverage checklist of answered and unanswered sub-questions, and whether the final report could survive a team meeting. Then imagine your competitor still using the chatbot.

FAQ

Q: How does Orbit's deep research actually work? A: Orbit runs an iterate-research loop: plan sub-questions, classify and generate queries, search multiple engines, extract content, delta-merge findings into a draft, check coverage, and repeat for 8–14 rounds before composing the final report.

Q: How many sources does Orbit research search? A: A deep run targets 65+ sources across 8–14 rounds. Fast mode runs a lighter pass with fewer searches for simpler questions.

Q: What do you get when research finishes? A: A final report saved as a durable artifact, an HTML report with source images, a coverage checklist of answered and unanswered sub-questions, and a chat brief you can read immediately — plus a Dig deeper option for follow-ups.

Q: Which models does Orbit use for research? A: Orbit routes across 150+ models by role: stronger reasoning models plan queries and write the final report, while faster, cheaper models handle the mechanical search and extraction rounds.

Build it on Orbit

Orbit's deep research engine runs 8–14 rounds across 65+ sources with honest coverage tracking and durable reports. Start building on Orbit.