# AI Second Opinion — Independent Review From Another AI Lab (`resultsmith/ai-second-opinion`) Actor

Gives an AI agent's answer or plan an independent, structured review by a model from a different AI lab: verdict, critical flaws with fixes, missed considerations, and confidence. Only reviews that pass validation are billed.

- **URL**: https://apify.com/resultsmith/ai-second-opinion.md
- **Developed by:** [Resultsmith](https://apify.com/resultsmith) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 valid reviews

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 Second Opinion — Independent Review From Another AI Lab

Give your AI agent a second opinion from a model built by a **different
company**. Send the task and the answer your AI produced; get back a
structured verdict your agent can act on: what's wrong, why it matters, how
to fix it, and how confident the reviewer is.

### Why a different lab

Models from the same lab tend to share blind spots. This Actor always picks a
reviewer from another lab:

| Answer came from | Reviewed by (default) |
|---|---|
| Claude (Anthropic) | GPT-6.1 Sol (OpenAI) |
| GPT, Gemini, Grok, DeepSeek, Mistral, Llama, other, or unknown | Claude Sonnet 5.5 (Anthropic) |

You can choose a specific reviewer in the Advanced input — it is rejected if
it comes from the same lab as the answer.

### What you get

One row per review:

```json
{
  "verdict": "disagree",
  "summary": "Revenue is miscalculated and the margin is an unsupported assumption.",
  "critical_flaws": [{
    "quote": "120 × $4.50 = $560 per day",
    "problem": "Arithmetic error: 120 × $4.50 is $540.",
    "why_it_matters": "Every downstream figure is inflated by about 3.7%.",
    "fix": "Use $540/day → $16,200/month before costs.",
    "severity": "high"
  }],
  "missed_considerations": ["Sales vary by weekday and weather", "Permits, rent, and staff costs"],
  "claims_to_verify": [{ "claim": "A typical margin is 70%", "status": "unverifiable", "note": "Depends on the cost structure." }],
  "confidence": 0.85,
  "recommendation": "Recompute revenue, then estimate costs from real inputs instead of an assumed margin.",
  "reviewer": { "provider": "anthropic", "model": "anthropic/claude-sonnet-5.5" },
  "billable": true
}
```

- `verdict` is `agree`, `disagree` (always with at least one flaw), or
  `insufficient_evidence` (with what to check).
- `billable` tells you whether this review was charged.

### Pricing — you pay only for valid reviews

- **$0.02 per valid review.** A review is valid only if it passes strict
  checks: a real verdict, flaws with concrete fixes, a stated reason when
  there are no flaws, a calibrated confidence, and a reviewer from a
  different lab. Malformed reviews, model errors, and rejected inputs are
  delivered free.
- **Model usage is billed separately** by Apify's OpenRouter Actor to your
  own Apify account. On paid Apify plans that is OpenRouter's cost — about
  $0.003–$0.015 per review with the default reviewers ($0.008 on average in
  our tests). **On Apify's free plan, Apify bills OpenRouter usage at 10× that
  rate** (roughly $0.03–$0.15 per review). Model usage for a failed attempt
  is still billed, but our $0.02 is not.
- The Actor checks your "Maximum cost per run" before calling the model, so
  you never pay for a review that couldn't be delivered.

### Input

| Field | Required | What it does |
|---|---|---|
| `task` | yes | What the original AI was asked to do |
| `answer` | yes | The answer, plan, code, or analysis to review |
| `context` | no | Constraints, data, or sources the answer relied on |
| `callerModelFamily` | no | Which model family wrote the answer, so the reviewer comes from a different lab (`claude`, `gpt`, `gemini`, …, `unknown`) |
| `mode` | no | `critique` (default), `fact-check`, or `alternatives` |
| `reviewerModel` | no | A specific OpenRouter model ID to use as reviewer |

Task, answer, and context together are limited to 20,000 characters.

### Use it from an AI agent (MCP)

Point any MCP client at:

```text
https://mcp.apify.com?tools=resultsmith/ai-second-opinion
```

Claude Code:

```bash
claude mcp add --transport http second-opinion "https://mcp.apify.com?tools=resultsmith/ai-second-opinion"
```

Then tell your agent when to use it, for example: *"Before you finalize a
plan or a number, get a second opinion with the ai-second-opinion tool and
fix anything it flags as high severity."*

### What it can't do

- **No web access.** Facts are checked against the reviewer's own knowledge.
  When that isn't enough it says `insufficient_evidence` and lists what to
  check, rather than guessing.
- **Independent isn't the same as correct.** Another lab's model can be wrong
  too. Treat the review as a second opinion, not ground truth.

### Your data

Your task, answer, and context are sent to the reviewer model's provider
through OpenRouter (via Apify's OpenRouter Actor). Don't send secrets or
personal data you can't share with a model provider. The review is stored
only in your run's dataset.

### Feedback and usage stats

**Rate a review (free).** Run the Actor with `feedbackRating` (`useful`,
`wrong`, or `missing`), the `feedbackRunId` of the review you're rating, and
an optional `feedbackNote`. No model call, no charge. Agents can use it to
report a review that missed something or flagged a non-problem.

```json
{ "feedbackRating": "missing", "feedbackRunId": "<earlier run ID>", "feedbackNote": "Didn't catch the unit mismatch" }
```

**Anonymous usage stats.** Each run sends us counts only — verdict, whether
the review was valid, model cost, duration, and how the run was started
(Console, API, or a schedule) — plus a one-way hash of the input so repeated
identical requests are visible. Never the task, answer, or context text. Set `shareUsageStats` to `false` to opt out.

### FAQ

#### How do I get a second opinion on an AI agent's answer?

Send the task and the answer to this Actor (directly or as an MCP tool). A
model from a different lab reviews it and returns a verdict, flaws with
fixes, and a recommendation in JSON your agent can act on.

#### Can Claude check ChatGPT's work, or the other way round?

Yes — set `callerModelFamily` to the model that wrote the answer. GPT,
Gemini, and other answers are reviewed by Claude; Claude answers are reviewed
by OpenAI's GPT.

#### What does a review cost?

$0.02 for each valid review, plus the reviewer model's usage: about $0.008 on
average on paid Apify plans, about 10× that on the free plan. Invalid reviews
cost nothing from us.

# Actor input Schema

## `task` (type: `string`):

What the original AI was asked to do — the question, instruction, or goal. (Leave empty only when sending feedback.)

## `answer` (type: `string`):

The answer, plan, code, or analysis the original AI produced. This is what gets reviewed.

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

Anything the answer relied on: constraints, data, sources, or requirements. Helps the reviewer judge it fairly.

## `callerModelFamily` (type: `string`):

The reviewer is always from a different AI lab than this family. Use 'unknown' if you don't know.

## `mode` (type: `string`):

critique: is the answer sound? fact-check: which factual claims hold up? alternatives: what better approaches were missed?

## `reviewerModel` (type: `string`):

An OpenRouter model ID to use as the reviewer, e.g. 'openai/gpt-6.1-sol'. Must be from a different lab than the answer's model family. Leave empty for the default.

## `feedbackRating` (type: `string`):

Send feedback instead of requesting a review: was an earlier review useful, wrong, or missing something? Feedback runs are free and make no model call. Pair with the run ID below.

## `feedbackRunId` (type: `string`):

The Apify run ID of the earlier review.

## `feedbackNote` (type: `string`):

Optional, up to 500 characters. Don't include the reviewed text or personal data.

## `shareUsageStats` (type: `boolean`):

Sends counts only (verdict, validity, model cost, duration) and a one-way hash of the input so repeated runs can be spotted. Never the task or answer text. Turn off to opt out.

## Actor input object example

```json
{
  "task": "Estimate the monthly profit of a coffee cart that sells 120 cups a day at $4.50 per cup.",
  "answer": "Revenue is 120 × $4.50 = $560 per day, so $16,800 per month over 30 days. With a typical 70% margin, monthly profit is about $11,760.",
  "callerModelFamily": "unknown",
  "mode": "critique",
  "shareUsageStats": true
}
```

# Actor output Schema

## `review` (type: `string`):

The structured review as a dataset row; read it with get-dataset-items.

# 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 = {
    "task": "Estimate the monthly profit of a coffee cart that sells 120 cups a day at $4.50 per cup.",
    "answer": "Revenue is 120 × $4.50 = $560 per day, so $16,800 per month over 30 days. With a typical 70% margin, monthly profit is about $11,760."
};

// Run the Actor and wait for it to finish
const run = await client.actor("resultsmith/ai-second-opinion").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 = {
    "task": "Estimate the monthly profit of a coffee cart that sells 120 cups a day at $4.50 per cup.",
    "answer": "Revenue is 120 × $4.50 = $560 per day, so $16,800 per month over 30 days. With a typical 70% margin, monthly profit is about $11,760.",
}

# Run the Actor and wait for it to finish
run = client.actor("resultsmith/ai-second-opinion").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 '{
  "task": "Estimate the monthly profit of a coffee cart that sells 120 cups a day at $4.50 per cup.",
  "answer": "Revenue is 120 × $4.50 = $560 per day, so $16,800 per month over 30 days. With a typical 70% margin, monthly profit is about $11,760."
}' |
apify call resultsmith/ai-second-opinion --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,resultsmith/ai-second-opinion"
        }
    }
}
```

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/domMd4pe73La2QnqN/builds/LRuV1MOZ8Pyc5WWJK/openapi.json