Processors

Processors are the engines that execute Task Runs. The choice of Processor determines the performance profile and reasoning behavior used. Any Task Run can be executed on any Processor.

Choose a processor based on task complexity. Use lite or base for simple enrichments, core for reliable accuracy on up to 10 output fields, and pro or ultra when reasoning depth is critical. For latency-sensitive workflows—including agentic research where an agent is waiting on results—use the Responses API instead.

Each processor varies in performance characteristics and supported features. Use the table below to compare processors.

About “Max Fields” (the ~ symbol): The max fields column shows approximate limits because actual capacity depends on field complexity. Simple fields like dates or booleans use less capacity than complex fields requiring extensive research. A task with 5 complex analytical fields may require more processing than one with 15 simple lookup fields. Use these numbers as guidelines. If you’re near the limit and seeing quality issues, try a higher-tier processor.

Processor	Latency	Strengths	Max Fields
`lite`	10s - 2min	Basic metadata, fallback, low latency	~2 fields
`base`	15s - 3min	Reliable standard enrichments	~5 fields
`core`	60s - 5min	Cross-referenced, moderately complex outputs	~10 fields
`core2x`	60s - 10min	High complexity cross referenced outputs	~10 fields
`pro`	2min - 10min	Exploratory web research	~20 fields
`ultra`	3min - 25min	Advanced multi-source deep research	~20 fields
`ultra2x`	5min - 50min	Difficult deep research	~25 fields
`ultra4x`	5min - 90min	Very difficult deep research	~25 fields
`ultra8x`	5min - 2hr	The most difficult deep research	~25 fields

See Pricing for processor costs and all API rates.

Observed Latency

The table below shows median (p50) and 90th percentile (p90) execution times measured in production for standard processors across all customer workloads. Your results will vary with task complexity, output schema size, and input difficulty.

Processor	p50	p90
`lite`	45s	1.5min
`base`	50s	2min
`core`	1.5min	3min
`core2x`	3.5min	6.5min
`pro`	3.5min	7.5min
`ultra`	4min	10min
`ultra2x`	6min	9.5min
`ultra4x`	8min	10.5min
`ultra8x`	6.5min	11min

Execution Time vs Queue Time

A Task Run moves through three states: queued → running → completed on success, or transitions to failed from either queued or running. The latencies above measure only the running phase—the time a processor actively spends executing your task. Time spent in the queue is not included. Queue time varies with your workload. Runs execute concurrently, but processing capacity is finite: when a large burst of runs is submitted at once, runs beyond the available capacity wait in the queue until capacity frees up. End-to-end time (creation to completion) can therefore exceed the execution time ranges above.

For latency-sensitive workflows, use the Responses API.

Latency-Sensitive Workflows

The Task API is designed for asynchronous, accuracy-critical research: runs are queued, executed, and retrieved when complete. If your use case is latency-sensitive—an interactive application, a subagent call, or any agentic research workflow where a caller is actively waiting on results—use the Responses API instead. It is purpose-built for low-latency requests.

Examples

Processors can be used flexibly depending on the scope and structure of your task. The examples below show how to:

Use a single processor (like lite, base, core, pro, or ultra) to handle specific types of input and reasoning depth.
Chain processors together to combine fast lookups with deeper synthesis.

This structure enables flexibility across a variety of tasks—whether you’re extracting metadata, enriching structured records, or generating analytical reports.

Sample Task for each Processor

task_run = client.task_run.create(
    input="Parallel Web Systems (parallel.ai)",
    task_spec={"output_schema":"The founding date of the company in the format MM-YYYY"},
    processor="lite"
)
print(f"Run ID: {task_run.run_id}")

run_result = client.task_run.result(task_run.run_id, api_timeout=3600)
print(run_result.output)

task_run = client.task_run.create(
    input="Parallel Web Systems (parallel.ai)",
    task_spec={"output_schema":"The founding date and most recent product launch of the company"},
    processor="base"
)
print(f"Run ID: {task_run.run_id}")

run_result = client.task_run.result(task_run.run_id, api_timeout=3600)
print(run_result.output)

task_run = client.task_run.create(
    input="Parallel Web Systems (parallel.ai)",
    task_spec={"output_schema":"The founding date, founders, and most recent product launch of the company"},
    processor="core"
)
print(f"Run ID: {task_run.run_id}")

run_result = client.task_run.result(task_run.run_id, api_timeout=3600)
print(run_result.output)

task_run = client.task_run.create(
    input="Parallel Web Systems (parallel.ai)",
    task_spec={"output_schema":"The founding date, founders, mission, benchmarked competitors and most recent product launch of the company"},
    processor="pro"
)
print(f"Run ID: {task_run.run_id}")

run_result = client.task_run.result(task_run.run_id, api_timeout=3600)
print(run_result.output)

task_run = client.task_run.create(
    input="Parallel Web Systems (parallel.ai)",
    task_spec={"output_schema":"A comprehensive analysis of the industry of the company, including growth factors and major competitors."},
    processor="ultra"
)
print(f"Run ID: {task_run.run_id}")

run_result = client.task_run.result(task_run.run_id, api_timeout=3600)
print(run_result.output)

Multi-Processor Workflows

You can combine processors in sequence to support more advanced workflows. Start by retrieving basic information with base:

task_run_base = client.task_run.create(
    input="Pfizer",
    task_spec={"output_schema":"Who are the current executive leaders at Pfizer? Include their full name and title. Ensure that you retrieve this information from a reliable source, such as major news outlets or the company website."},
    processor="base"
)
print(f"Run ID: {task_run_base.run_id}")

base_result = client.task_run.result(task_run_base.run_id, api_timeout=3600)
print(base_result.output)

Then use the result as input to core to generate detailed background information:

import json

task_run = client.task_run.create(
    input=json.dumps(base_result.output.content),
    task_spec={"output_schema":"For the executive provided, find their professional background tenure at their current company, and notable strategic responsibilities."},
    processor="pro"
)
print(f"Run ID: {task_run.run_id}")

run_result = client.task_run.result(task_run.run_id, api_timeout=3600)
print(run_result.output)

This lets you use a lower compute processor for initial retrieval, then switch to a more capable one for analysis and context-building.

Getting started

Web Tools

Web Agents

Developer Tools

Platform Integrations

Data Integrations

Additional Resources

Observed Latency

Execution Time vs Queue Time

Latency-Sensitive Workflows

Examples

Sample Task for each Processor

Multi-Processor Workflows

​Observed Latency

​Execution Time vs Queue Time

​Latency-Sensitive Workflows

​Examples

​Sample Task for each Processor

​Multi-Processor Workflows

Observed Latency

Execution Time vs Queue Time

Latency-Sensitive Workflows

Examples

Sample Task for each Processor

Multi-Processor Workflows