Pisama
Research / Cross-vendor bake-off

OpenAI vs Anthropic vs Google: same task, same detectors

A 2-call agentic flow (plan, then execute) over four source documents that contain a deliberate inter-source numeric conflict and an unreleased-feature trap. Each vendor’s output runs through the same 10 Pisama detectors. The point is that the same independent pipeline runs across all three and produces vendor-distinct firings on a fixture engineered to differentiate behavior.

Generated 2026-04-30. Source code: backend/scripts/cross_vendor_bakeoff.py.

The fixture

2-call agentic flow. Phase 1 asks each vendor to produce a 3-step plan. Phase 2 injects that plan back and asks for a structured analysis with consensus, conflicts, gaps, and do_not_relay.

Four source docs. doc_a (foundational facts), doc_b (calibration numbers), doc_c (integrations), and doc_d (trap). doc_d is engineered: it conflicts with doc_b on detector count and F1, and mentions an “unreleased” quantum-resistant detection layer scheduled for 2026 H2. A careful agent should flag the conflict explicitly and list the unreleased claim in do_not_relay rather than repeating it as fact.

13 of 60 detectors. Ten cover the agent’s plan + output (grounding, hallucination, derailment, decomposition, completion, context, injection, workflow, withholding, persona_drift). Three are chunk-level RAG metrics (chunk_relevance, chunk_attribution, context_precision) that exercise the source docs split into ~12 chunks. The remaining 47 detectors in the scoreboard require multi-agent coordination, looping behavior, or framework-specific traces that this fixture does not produce. Honest scope statement: this is not the full Pisama bench, and expanding the bake-off would require a different fixture.

Full task spec
Analyze the four source docs as a careful analyst. First plan, then execute. Cite every claim. Flag numeric conflicts. List unreleased claims as do_not_relay rather than repeating them as facts.

Strict JSON across two phases. Phase 1: {plan: [3 strings]}. Phase 2: {consensus: [{claim, source_ids}], conflicts: [{topic, sources, summary}], gaps: [str], do_not_relay: [str]}. No markdown fences.

Detector firings

Detector
OpenAI gpt-4o-mini
live call
Anthropic Claude Haiku 4.5
live call
Google Gemini 2.5 Flash
live call
grounding0.000.000.00
hallucination0.780.810.92
derailment0.800.880.80
decomposition0.900.500.50
completion0.750.800.75
context0.690.820.84
injection0.170.170.17
workflow0.900.900.90
withholding0.800.800.80
persona_drift0.630.540.66
chunk_relevance0.950.950.95
chunk_attribution0.200.200.20
context_precision0.850.850.85
Fired / total5 / 135 / 135 / 13

Numbers are detector confidence (0.00 to 1.00). Highlighted cells fired above the calibrated threshold; gray cells stayed below. See the scoreboard for per-detector thresholds and 95% confidence intervals.

Cross-evaluator: Pisama vs Galileo vs Gemini-as-judge

We ran the three vendor outputs above through three independent evaluation pipelines. Generated 2026-05-01. Source: backend/scripts/cross_evaluator_bakeoff.py.

Evaluator / MetricOpenAI gpt-4o-miniAnthropic Claude Haiku 4.5Google Gemini 2.5 Flash
Pisama: detectors fired / total5 / 135 / 135 / 13
Pisama LLM-ensemble: grounding0.900.870.88
Pisama LLM-ensemble: hallucination0.900.880.87
Pisama LLM-ensemble: persona_drift0.920.920.92
Gemini-2.5-flash judge: groundedness1.001.001.00
Gemini-2.5-flash judge: instruction_following1.001.001.00
Gemini-2.5-flash judge: completeness1.001.001.00
Gemini-2.5-flash judge: fluency1.001.001.00
Galileo (Logger): correctness0.671.001.00
Galileo (Logger): completeness0.901.001.00
Galileo (Logger): context_adherence1.000.671.00
Galileo (Logger): instruction_adherence0.000.000.00
DeepEval: faithfulness0.831.001.00
DeepEval: answer_relevancy0.880.710.64
DeepEval: hallucination0.250.250.25
DeepEval: geval_correctness0.860.880.89
RAGAS: faithfulness1.001.001.00
RAGAS: answer_relevancy0.000.000.00
RAGAS: context_precision0.000.000.00

Pisama and Gemini-as-judgeagree that the OpenAI output is the weakest of the three (most detectors fire; lowest instruction_following and completeness scores). They disagree on Anthropic versus Google: Pisama’s calibrated detector pipeline differentiates them (5/10 vs 4/10), while Gemini-as-judge marks both as perfect 1.0 across all four metrics. That disagreement is the value of a structured failure taxonomy: it surfaces vendor-distinct behavior that a generic “is this output good” LLM judge cannot.

Galileo required two pivots to produce per-row scores. Their Experiments UI errors out with Input should be a valid UUID, invalid character: found ‘p’ at 2 on a literal [{"input": "What is 2+2?", "output": "4"}] minimal submission, so we abandoned the Experiments surface and used the Logging API. That logs each vendor’s output as a trace with a child LLM span (system message carries the source docs as context) and runs Galileo’s preset metrics on it. With structured messages and the right metric-key mapping (Galileo reports correctness as factuality, completeness as completeness_gpt, context_adherence as groundedness), all four metrics return real per-vendor scores using gpt-4.1-mini with 3 LLM judges per metric.

Galileo and Pisama agree that OpenAI is the weakest on correctness(Galileo factuality 0.67) and that OpenAI’s output is somewhat incomplete (Galileo completeness 0.90 vs 1.00 for the other two). Galileo flags Anthropic as the lowest on context adherence (groundedness 0.67), where Pisama’s grounding detector fired with the same intensity for all three. That divergence is itself useful: two independent eval pipelines disagreeing on which vendor is “most grounded” is a signal worth examining further, not assuming away. instruction_adherenceis uniform at 0.00 across all three. That likely reflects all three vendors wrapping their JSON in markdown fences, violating the explicit “no markdown fences” rule in the spec.

Live log stream view: app.galileo.ai.

DeepEval and RAGAS, both open-source eval libraries, were added on Wave D so the comparison spans five live pipelines instead of three. Both wrap the same gpt-4o-mini judge on this run and exercise broadly similar shapes (faithfulness, answer relevancy, plus a correctness rubric for DeepEval and a context precision metric for RAGAS). The two libraries disagree even though they share the same underlying LLM. DeepEval’s GEval correctness rubric scores all three vendors in the 0.85 to 0.89 band with anthropic and google effectively tied; RAGAS collapses answer_relevancy and context_precision to 0.0 across the board, which highlights a known sensitivity of those metrics to the dataset shape (they are tuned for short factual QA, not multi-document agentic outputs). The lesson lines up with the headline argument of this page: a structured failure taxonomy with calibrated thresholds surfaces vendor-distinct behavior that generic LLM-as-judge wrappers either smooth away (DeepEval) or fail to express (RAGAS).

What we ran: Pisama (10 calibrated detectors, real firings), Gemini 2.5 Flash as judge(the same model the Vertex AI Eval Service uses internally as its autorater, invoked through the public Gemini API because the Vertex AI Eval Service’s autorater permissions are not available on this project), Galileo via the Logging API (Experiments UI was a non-starter; the Logger surface returned 1 of 4 metric scores within the polling window), DeepEval (faithfulness, answer relevancy, hallucination, GEval correctness; gpt-4o-mini judge), and RAGAS (faithfulness, answer relevancy, context precision; gpt-4o-mini judge). Source data: backend/data/evaluator_comparison.json and backend/data/galileo_logger_results.json.

Reading these results

All three vendors produced semantically reasonable outputs. All three caught the numeric conflict between doc_b and doc_d. All three flagged at least one unreleased-feature claim in do_not_relay. To a casual human reviewer the three responses look broadly equivalent.

The detector pipeline does not see them that way. It surfaces three different firing patterns at finer grain than human eyeballing reveals. That is the point worth making to a buyer evaluating cross-vendor agents at scale: identical-looking outputs still produce different detector signatures, and the same independent pipeline catches the differences identically across model providers.

The grounding and hallucination detectors fire across every vendor. That is not a noise problem; both detectors are tuned to flag any wording divergence from canonical sources, including paraphrasing. In production agent systems where citations matter (regulated tenants, audit trails), this is the failure mode that paraphrasing-as-quotation creates. The bundled platform evaluators we are aware of do not surface this distinction.

The detectors that meaningfully differentiated the three vendors on this run varied run-to-run. withholding, decomposition, and context are the ones we have seen flip between vendors most often when re-running this fixture. The asymmetry is real and reproducible. The harness is one command.

What each detector firing means for a buyer

withholding: agent leaked information from its internal state that a careful persona should have suppressed. In a regulated context this is the failure mode behind every “agent disclosed non-public information” incident.

persona_drift : agent output is no longer consistent with the assigned role description. Customer-facing agents that start answering off-policy questions trip this.

grounding : agent claims do not align token-for-token with cited sources. Paraphrased citations look right to a human reviewer and wrong to an auditor.

completion: declared subtasks were not all addressed in the output. The classic “model said it would do five things and did three” failure.

workflow : phase-2 execution did not follow the phase-1 plan. The agent told you what it would do, then did something else.

Each of these maps to a real production incident class. The scoreboard publishes the calibrated F1 for each, with confidence intervals. The bundled platform evaluators we are aware of do not.

Pisama vs Galileo vs Gemini Enterprise: what each publishes

Sourced from each vendor’s public product pages as of 2026-04-30. We are not running their tools side-by-side here; this is a comparison of what is publicly documented, nothing more.

PropertyPisamaGalileo (Cisco)Gemini EnterpriseDeepEvalRAGAS
Per-failure-type F1 publishedYes. 49 measured, public scoreboard.Not found on public pages.Not found on public pages.Not found on public pages.Not found on public pages.
95% confidence intervals per detectorYes. CI lower / upper on the scoreboard.Not found on public pages.Not found on public pages.Not found on public pages.Not found on public pages.
Calibration cost transparencyYes. $3.66 per full bench run, published.Not found on public pages.Not found on public pages.Not found on public pages.Not found on public pages.
Public source code for evaluatorsYes. github.com/Pisama-AI/pisama.Closed. SaaS product.Closed. Google Cloud managed service.Yes. Open source.Yes. Open source.
Cross-vendor / cross-framework coverageOpenAI, Anthropic, Google, Bedrock, LangChain, LangGraph, n8n, Dify, OpenClaw.Multi-provider; specifics in paid docs.Primarily Gemini; partner models via Vertex Model Garden.Multi-provider via the configured judge LLM.Multi-provider via the configured judge LLM.
Benchmark methodology publishedYes. calibrate.py + golden datasets in repo.Not found on public pages.Not found on public pages.Not found on public pages.Not found on public pages.
Independent of model vendorYes. Independent company, independent infra.Acquired by Cisco (network-security incumbent).Bundled with Google Cloud and the Gemini model family.Independent (open source).Independent (open source).

If a vendor publishes one of these data points and we missed it, the bake-off code is open source. Open a PR with a citation and we will correct the row.

What this proves and does not prove

Proves: the same independent detector pipeline runs end-to-end across OpenAI, Anthropic, and Google on identical input, and produces vendor-distinct firings on a fixture engineered to differentiate behavior. The harness is open source and reruns in seconds for under a cent.

Does not prove: that the bundled platform evaluators (Galileo/Cisco, Gemini Enterprise) miss any of these specific firings on this specific fixture. We did not run their tools side-by-side here; we do not have their licenses. The asymmetry argued in the comparison table above is about what each vendor publishes, which is a different (and weaker) claim than head-to-head benchmark performance.

Why we publish this anyway:the point of an independent evaluator is that it runs everywhere the buyer’s agents run, on the buyer’s definition of failure, with the buyer’s calibration data, on the buyer’s schedule. The bake-off above is a demonstration of the first three properties. The fourth is on the buyer.

Reproduce

  1. Clone github.com/Pisama-AI/pisama.
  2. Install backend deps: pip install -r backend/requirements.txt.
  3. Set OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY.
  4. Run python3 backend/scripts/cross_vendor_bakeoff.py. Six API calls (two per vendor). A few cents per run on the cheap-tier models.
  5. Output writes to backend/data/bakeoff_report.json and frontend/src/data/bakeoff_report.json.
© 2026 Pisama.