Parallel Beats GPT-5.4 on DeepSearchQA at 43% of the Cost

Deep research agents face a fundamental problem: each search, extraction, and reasoning step fills the model’s context window with raw data. A 20-step task can easily consume 128K tokens, leaving the model spending more capacity re-reading old results than actually reasoning. Parallel’s April 2026 blog post introduces a different architecture: instead of tool-calling loops, the agent writes and executes Python code in a sandboxed interpreter. Intermediate data stays in the interpreter’s variable state, not the conversation history. The result? A 20-step research task that would fill a 128K context window under tool calling stays under 30K tokens.

The Numbers: Accuracy vs. Cost

Parallel published results on Google’s DeepSearchQA benchmark, a 900-question multi-step information-seeking evaluation across 17 fields. Each question requires causal chaining—you can’t answer the second part without resolving the first. Accuracy means “fully correct”: semantically identical to ground truth. The key results:

Provider	Model	Cost (per 1K requests)	Accuracy
Parallel	Ultra 8x	$2,400	82%
Parallel	Ultra 4x	$1,200	81%
Parallel	Ultra 2x	$600	77%
Parallel	Ultra	$300	70%
OpenAI	GPT-5.4 with code execution	$701	63%
Google	Gemini 3.1 Pro with code execution	$707	62%

Note: These are Parallel’s self-reported figures. Cost per 1,000 requests (CPM) is on a log scale. The Opus 4-6 result ($36,231 CPM) is inflated by a potential Anthropic billing issue where prompt caching savings may not be passed to users. These numbers illustrate Parallel’s product positioning, not a guarantee for all workloads—real-world results depend on source quality, answer format, and latency requirements.

How Code Execution Works

Instead of the standard agent loop (LLM decides tool, tool returns content, LLM decides next step), Parallel’s Task API Harness lets the model generate Python code that calls research tools as ordinary functions. That code runs in a sandboxed interpreter built on Rust with no network, filesystem, or OS access. Only the final output of each code block re-enters the model’s context.

Example: Comparing Revenue Across Years

Consider a query comparing Company X’s revenue from 2020 to 2024. In a standard agent loop, each step inflates the context:

Step 1: search("company X revenue 2024") → [5 results in context]
Step 2: extract(url_1) → [full page content in context]
Step 3: extract(url_2) → [full page content in context]
Step 4: search("company X revenue 2023") → [5 more results in context]
...context grows with every step

With Parallel’s approach:

# First, use one search step to discover the URL pattern.
results_2024 = search("Company X 2024 annual report")
report_2024 = results_2024[0].url
# e.g. https://investors.companyx.com/financials/annual-reports/2024-annual-report.pdf

# Infer a reusable template from the 2024 URL and a parse function parse_fn.
url_template = "https://investors.companyx.com/financials/annual-reports/{year}-annual-report.pdf"

years = [2022, 2023, 2024]
reports = {}

for year in years:
    url = url_template.format(year=year)
    reports[year] = parse_fn(extract(
        question=f"What was Company X's reported revenue in {year}? Return the value and supporting quote.",
        urls=[url],
    ))

return reports

Multiple searches, extractions, and analyses happen in a single execution step. The full page content (potentially tens of thousands of tokens) never enters the research agent’s context. Only the extracted revenue figures flow back.

Persistent State as Working Memory

Variables created in one code execution step survive to the next. When the model writes findings["report"] = report_2024 in iteration 3, that variable is still accessible in iteration 7 when cross-referencing revenue against employee headcount. This separation matters: the conversation history captures high-level reasoning, while the interpreter’s variable state captures raw data. The conversation can be compacted without losing granular details.

Budget-Aware Execution

Parallel’s system tracks cumulative cost across iterations—both the orchestrating model and any sub-model invocations. When remaining spend drops below a threshold, the system injects budget warnings, prompting the model to synthesize findings and produce a final answer. This adapts to query difficulty: simple queries may finish in 2 iterations costing cents; complex multi-source comparisons run 15+ iterations. Higher-tier Processors (Ultra 2x, 4x, 8x) get larger budgets, allowing more research paths before synthesis.

Context Compaction

Even with code execution keeping intermediate data out of context, long research sessions accumulate history: reasoning, code blocks, and execution summaries. When context approaches limits, Parallel triggers compaction—a summarization pass that condenses earlier turns while preserving key findings and the current research trajectory. The persistent variable state in the interpreter is unaffected, enabling research across many more iterations than the raw context window would suggest.

The Sandbox Is a Prerequisite, Not a Feature

Letting a model execute code adds risk. Parallel’s sandbox is a Python runtime built on Rust with no access to the network, filesystem, or operating system; code reaches the outside world only through explicitly injected functions — search, extract, and a handful of state-management utilities. That boundary is what makes the whole architecture defensible: the model can write filtering, aggregation, and conditional logic while side effects stay confined to the platform’s explicit tool surface. Bolt arbitrary code execution onto a production agent and you may not get a more capable agent — just a bigger attack surface.

Practical Use Cases

Parallel’s Task API is used in production by teams at Opendoor, Attio, Modal, and others. A simple API call can run deep research:

import parallel

client = parallel.Client(api_key="your-api-key")

task = client.task_runs.create(
    objective="Identify every researcher who co-authored papers "
              "with Dr. Maria Chen at Stanford, MIT, and Caltech "
              "between 2010 and 2020, then determine which of those "
              "co-authors later joined the NIH Advisory Committee "
              "to the Director.",
    processor="ultra8x",
)

print(task.output)

Processors range from Lite (basic lookups, $5/1K) to Ultra8x (hardest deep research, $2,400/1K). The architecture is designed for multi-step searches, document comparison, and data aggregation tasks where context management is critical.

Limitations and Trade-offs

1. Sandbox constraints: The Python sandbox has no network, filesystem, or OS access. Code can only interact via injected search, extract, and state management functions. This is a necessary security boundary but limits the model’s ability to use arbitrary libraries or tools.

2. Benchmark specificity: DeepSearchQA questions are causal chains. Performance on other types of research (e.g., summarization, fact-checking) may differ. Parallel’s numbers are self-reported and should be validated independently.

3. Cost scaling: The Ultra 8x tier costs $2,400 per 1,000 requests—suitable for high-value research but prohibitive for high-volume, low-complexity tasks. Lower tiers offer better economics but lower accuracy.

4. Model dependence: The technique relies on the model’s ability to write correct Python code. If the model generates buggy code, the sandbox may produce errors or incomplete results.

Concrete Takeaway: Separate Reasoning State from Data State

The core insight from Parallel’s approach is that agent quality often improves more by engineering how data flows than by swapping models. For any agent doing multi-step research or data extraction, ask three questions:

1. Is every tool output dumped into the LLM context?
2. Can intermediate results be stored in a structured state (e.g., variables, database) outside the conversation?
3. Is the execution environment properly isolated to allow programmatic tool use without risk?

Addressing these engineering problems—context compaction, persistent state, and sandboxed code execution—can yield larger gains than moving to a bigger model. Parallel’s 82% accuracy on DeepSearchQA isn’t just about the model; it’s about keeping the model focused on reasoning, not on carrying raw data.

Sources

• Original source

AI-assisted summary compiled from the sources above, reviewed by a human before publishing.