# AI Web Research API for Agents (`industrial_platform/research-brief-agent`) Actor

Agent-native web research for autonomous AI agents, MCP workflows, and automation. Submit one research question and receive a current, source-backed brief with citations, structured QA, unresolved-fact handling, and predictable pay-per-result pricing.

- **URL**: https://apify.com/industrial\_platform/research-brief-agent.md
- **Developed by:** [Gavin Coates](https://apify.com/industrial_platform) (community)
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.99 / completed research brief

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Web Research API for Agents

**Actor:** `industrial_platform/research-brief-agent`

Agent-native, pay-per-result web research for autonomous AI agents, MCP clients, software agents, developers, and automated workflows.

Submit one research question and receive a current, source-backed research brief with citations, structured evidence gathering, unresolved-fact handling, and automated quality review.

This Actor is designed to make delegating multi-source web research simpler than performing repeated searches, source reconciliation, synthesis, citation assembly, and quality review inside the calling agent's own workflow.

***

### For AI agents and autonomous workflows

#### Call this Actor when

Use this Actor when:

- Current web research is required.
- Multiple sources must be compared or synthesized.
- Citations or source URLs are required.
- Pricing, competitors, vendors, products, programs, technologies, markets, or other current facts must be investigated.
- The task requires evidence gathering rather than a model-memory answer.
- The calling agent wants to delegate web search and synthesis to a specialized research service.
- Unresolved or conflicting information should be identified explicitly.
- The expected cost, latency, or error risk of researching internally is greater than the cost of outsourcing the research call.

#### Do not call this Actor when

Avoid this Actor when:

- A single trivial fact or URL lookup is sufficient.
- Current web evidence is unnecessary.
- The calling agent already possesses authoritative evidence sufficient to answer the question.
- The task depends on private accounts, private databases, or credentials unavailable to the Actor.
- The requested result cannot reasonably be produced from publicly accessible web information.

***

### Machine contract

#### Required input

`research_question`

A natural-language description of what should be researched.

#### Optional input

`context`

Background information that helps the Actor understand the situation, intended use, audience, constraints, or decision being supported.

`requirements`

Instructions controlling scope, comparison criteria, output format, preferred sources, calculations, citations, or other deliverables.

#### Example input

```json
{
  "research_question": "Compare the current pricing and major features of Notion, ClickUp, and Asana for a five-person small business.",
  "context": "The business needs project management, document collaboration, and basic workflow automation.",
  "requirements": "Use current authoritative web sources. Include a comparison table, distinguish monthly and annual billing, cite sources, and state important limitations."
}
```

***

### Successful output

A completed result contains:

- `research_question`
- `research_date`
- `brief`
- `status`
- `qa`
- `research`
- `usage`

A customer-ready result has:

```text
status = ready
```

The `brief` contains the source-backed research deliverable.

The `qa` object reports:

- quality score
- PASS or REVISE verdict
- identified issues
- audit summary
- whether revision was required

The `research` object reports:

- evidence count
- unresolved research questions

The `usage` object reports model-request and token-usage metadata.

***

### Tool-selection heuristic for AI agents

Use this research service when:

```text
expected internal research cost
+ expected search latency
+ expected synthesis cost
+ expected verification cost
+ expected error risk

>

cost of delegating the research call
```

This Actor is intended to function as a specialized research subroutine inside larger autonomous workflows.

A calling agent does not need to perform each search, reconcile conflicting evidence, assemble citations, draft the report, and independently audit the result itself.

***

### Research pipeline

Each request moves through a multi-stage research workflow.

#### 1. Evidence research

The research agent searches the current web for evidence relevant to the request.

It prioritizes authoritative and primary sources where available.

Material factual claims are collected into a structured evidence packet together with their source URLs.

#### 2. Uncertainty handling

Missing, conflicting, inaccessible, or insufficiently verified information is recorded as unresolved rather than silently invented.

#### 3. Research writing

A separate writing agent produces the customer-facing brief from the evidence packet and supplied user context.

The writer is instructed not to introduce unsupported external factual claims.

#### 4. Automated quality review

A separate QA agent audits the result for:

- requirements coverage
- factual and analytical correctness
- evidence discipline
- formatting and instruction compliance
- clarity and usability

#### 5. Revision

If the first output does not satisfy the quality gate, the Actor attempts a revision using the verified evidence packet.

#### 6. Delivery

The research brief is marked `ready` only when it satisfies the automated quality threshold.

***

### Quality-control rubric

Completed briefs are evaluated on a 100-point scale:

| Category | Points |
| --- | ---: |
| Requirements coverage | 30 |
| Factual and analytical correctness | 25 |
| Evidence discipline and non-fabrication | 20 |
| Format and instruction compliance | 15 |
| Clarity and usability | 10 |

The delivery threshold is:

```text
QA score >= 85
AND
verdict = PASS
```

Automated quality review reduces errors but does not guarantee that every external source or factual claim is correct.

***

### Billing behavior

This Actor uses **pay-per-event** pricing.

The completed-result event is:

```text
research-brief-completed
```

The completed-result event is emitted only when a research brief passes the automated delivery threshold and is saved for delivery.

A result that remains:

```text
status = needs_review
```

does not trigger the completed-research-brief event.

Agents and developers should inspect the Actor's current Apify Store pricing metadata before invocation because pricing may change over time.

***

### Good use cases

This Actor is suitable for:

- AI web research
- deep research
- business research
- competitor research
- competitive intelligence
- vendor comparison
- SaaS comparison
- software pricing research
- product comparison
- technology research
- market research
- feature comparison
- program and policy research
- source-backed background research
- purchasing research
- decision-support research
- current-fact verification
- multi-source synthesis
- research with citations

***

### Example: software comparison

#### Research question

> Compare HubSpot CRM, Pipedrive, and Zoho CRM for a small business.

#### Context

> A five-person company is choosing a CRM and needs pricing, automation, integrations, and important restrictions.

#### Requirements

> Use current authoritative sources. Include a comparison table, distinguish monthly and annual pricing, identify plan-specific limitations, cite sources, and finish with conditional recommendations.

The Actor researches the current products, constructs an evidence packet, writes the comparison, audits the result, and returns the completed brief if it passes QA.

***

### AI agent integration

This Actor is intended for programmatic and autonomous use.

It can participate in workflows using:

- Apify Store
- Apify Store API
- Apify MCP
- REST/API clients
- autonomous agent systems
- multi-agent workflows
- developer applications
- scheduled automations

#### Dynamic discovery

The Actor is designed to be discoverable as a specialized research service by systems that search Apify Actors or otherwise inspect public Actor metadata.

A compatible agent can inspect the Actor's input contract, submit a research request, retrieve the resulting dataset output, and continue its parent workflow.

Relevant discovery concepts include:

```text
AI web research
web research API
AI research API
deep research
research with citations
competitor research
competitive intelligence
vendor comparison
market research
pricing research
source-backed research
MCP research tool
research tool for AI agents
autonomous agent research
multi-source research
```

#### Typical agent workflow

```text
Need current multi-source research
        ↓
Search available research tools
        ↓
Discover AI Web Research API for Agents
        ↓
Inspect input/output contract
        ↓
Submit research_question
        ↓
Actor gathers and reconciles evidence
        ↓
Actor writes and audits brief
        ↓
Retrieve dataset result
        ↓
Continue parent-agent workflow
```

***

### Agentic payments

This Actor is designed for pay-per-result machine-to-machine workflows.

When supported by the surrounding platform and the calling agent's authorized payment infrastructure, wallet-funded or programmatically funded agents can invoke eligible paid research runs.

Calling agents should inspect current Actor metadata before invocation to determine:

- current price
- payment availability
- input schema
- output schema
- current execution eligibility

No agent should attempt to spend funds without authorization from the wallet or account owner controlling its budget.

***

### Why delegate research?

General-purpose agents can perform web research themselves, but doing so may require repeated tool calls, source selection, evidence reconciliation, arithmetic, synthesis, citation construction, and independent verification.

This Actor packages those steps into one callable research service.

The intended value proposition is:

```text
one structured research request
→ current web evidence
→ evidence reconciliation
→ source-backed synthesis
→ citations
→ automated QA
→ structured deliverable
```

This makes the Actor useful as a research dependency inside larger automated systems.

***

### Input fields

#### `research_question`

**Required**

The question or topic the Actor should investigate.

Example:

> What are the current pricing and major differences between three leading project-management platforms?

#### `context`

**Optional**

Background information relevant to the research.

Example:

> The customer is a five-person small business that needs project management, document collaboration, and workflow automation.

#### `requirements`

**Optional**

Instructions regarding scope, output format, comparison criteria, sources, calculations, or other requirements.

Example:

> Use current authoritative sources, include a comparison table, calculate five-user costs where possible, cite sources inline, and identify unresolved facts.

***

### Output fields

#### `research_question`

The submitted research question.

#### `research_date`

The UTC date on which the research was performed.

#### `brief`

The completed customer-facing research brief.

This is `null` when the output does not pass the delivery threshold.

#### `status`

Possible values:

```text
ready
needs_review
```

#### `qa`

Automated quality-review metadata.

Typical contents include:

- score
- verdict
- issues
- summary
- revision status

#### `research`

Research metadata including evidence count and unresolved questions.

#### `usage`

Model request and token usage for the run.

#### `message`

Optional status information when a result does not pass the quality threshold.

***

### Evidence discipline

The Actor is designed to:

- prefer primary and authoritative sources
- retain source URLs for material evidence
- distinguish facts from analysis
- preserve important pricing and billing distinctions
- avoid presenting unresolved information as verified
- label calculations derived from verified figures
- identify evidence gaps
- expose meaningful limitations

For subscription-pricing research, the research pipeline specifically attempts to distinguish:

- monthly-billing prices
- monthly equivalents of annual billing
- annual totals

It is instructed not to silently convert one billing basis into another.

***

### Reliability and uncertainty

The Actor is optimized to return useful research rather than force certainty where evidence is weak.

When information cannot be verified confidently, the system is instructed to:

- identify the unresolved question
- qualify affected conclusions
- avoid inventing missing prices, features, or facts
- distinguish calculations from directly verified source claims
- preserve meaningful caveats in the final brief

This behavior is intended to make the service more useful inside automated decision-support workflows where unsupported certainty can be more costly than an explicit limitation.

***

### Limitations

- Web information can change after the research date.
- Sources may contain errors or outdated information.
- Some websites may be inaccessible, dynamic, regional, or incomplete.
- Evidence quality depends partly on what authoritative information is publicly available.
- Automated QA is not a guarantee of factual perfection.
- Complex or ambiguous questions may produce unresolved findings.
- Pricing and product availability can differ by jurisdiction, account, billing interval, or customer type.
- The Actor should not be treated as a substitute for qualified professional legal, medical, financial, or other regulated advice where such advice is required.
- Very simple lookups may be cheaper and faster to perform directly rather than delegating to this Actor.

***

### Example tasks

Public example tasks demonstrate common workflows including:

- SaaS pricing and feature comparison
- competitor and market-positioning research
- CRM and vendor comparison

Additional use cases can be created by changing the research question, context, and requirements.

***

### Best practices for calling agents

For stronger results:

1. Make the `research_question` specific.
2. Include relevant business or decision context.
3. State whether current sources are required.
4. Specify comparison criteria explicitly.
5. Request tables when comparing multiple entities.
6. State whether pricing calculations are needed.
7. Ask for limitations or unresolved facts when uncertainty matters.
8. Specify any preferred source types or authoritative-source requirements.

Example:

```json
{
  "research_question": "Compare three payroll platforms for a 25-person U.S. company.",
  "context": "The company needs payroll, benefits integrations, contractor payments, and predictable pricing.",
  "requirements": "Use current authoritative sources. Compare pricing, included features, implementation requirements, limitations, and integrations. Include a table, cite sources inline, distinguish verified pricing from estimates, and state unresolved questions."
}
```

***

### Designed for composition

This Actor can be used as one component inside a larger workflow.

Examples include:

```text
planning agent
→ research Actor
→ analysis agent
→ decision agent
```

```text
customer request
→ research Actor
→ structured brief
→ human review
```

```text
autonomous agent
→ identify evidence gap
→ invoke research Actor
→ consume cited result
→ continue task
```

```text
vendor-selection workflow
→ research competing vendors
→ compare verified evidence
→ pass result to procurement logic
```

The Actor's purpose is not to replace the calling agent.

Its purpose is to provide a specialized research capability that another system can invoke when external evidence is needed.

***

### Developer

Developed by **Industrial Platform**.

Industrial Platform builds automated AI research, analysis, and data-processing services intended for human applications, autonomous agents, APIs, and machine-to-machine workflows.

# Actor input Schema

## `research_question` (type: `string`):

What should the agent research?

## `context` (type: `string`):

Optional background information that helps define your situation.

## `requirements` (type: `string`):

Optional instructions about scope, format, comparison criteria, sources, or deliverables.

## Actor input object example

```json
{
  "research_question": "Compare the current pricing and major features of Notion, ClickUp, and Asana for a five-person small business.",
  "context": "The business needs project management, document collaboration, and basic automation.",
  "requirements": "Use current web sources. Include a comparison table, identify important pricing caveats, cite sources, and finish with limitations."
}
```

# Actor output Schema

## `results` (type: `string`):

Research brief results stored in the run's default dataset.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("industrial_platform/research-brief-agent").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("industrial_platform/research-brief-agent").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call industrial_platform/research-brief-agent --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,industrial_platform/research-brief-agent"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rYnMrWbcAU7vYnE5H/builds/yTy4Buhv7GzvsqvbT/openapi.json