Forem: E S

LLM Hallucination Index 2026: Why Claude 4.6 Sonnet Dominates BullshitBench v2 While Reasoning Models Fail

E S — Tue, 03 Mar 2026 15:37:41 +0000

In the relentless race toward Artificial General Intelligence, the industry has become obsessed with a dangerous proxy for intelligence: Helpfulness. We have trained LLMs to be the ultimate “yes-men,” optimizing them to provide an answer at any cost.

The release of BullshitBench v2 is a cold, empirical shower for this narrative. While standard benchmarks like MMLU are hitting their ceilings, this specialized stress test — designed specifically to catch models in a lie — reveals a widening “honesty gap” that separates the pretenders from the truth-tellers.

The Reasoning Paradox: More Compute, More Delusion
The most significant takeaway from the v2 data is the definitive confirmation of the “Reasoning Paradox.” The prevailing wisdom was that Chain-of-Thought (CoT) and increased inference-time compute would allow models to self-correct. BullshitBench v2 proves the opposite for the vast majority of the field.

For most models, including the latest iterations of GPT-5.2 and Gemini 3 Pro, deeper reasoning actually lowers the success rate in detecting nonsense. Instead of using logic to debunk a false premise, the models use their increased “brain power” as a rationalization engine.

If you feed a “smart” model a non-existent legal statute, it won’t flag the error. Instead, it will spend 30 seconds of compute explaining why that fake law is a perfectly logical extension of the current legal system. The more “intelligent” the model, the more convincingly it can justify absolute bullshit.

The 2026 Reliability Hierarchy: Anthropic’s Hegemony
The v2 leaderboard reveals a brutal divergence in the market. While most labs are plateauing, Anthropic has managed to build what can only be described as a “Skepticism Layer” into their architecture.

The Claude 4.6 Phenomenon: Breaking the 90% Barrier Anthropic is the only vendor currently showing a consistent upward trajectory in “epistemic humility.”

Claude Sonnet 4.6 (High Reasoning) sits at the absolute top with a 91.0% Green Rate (successful BS detection).

Crucially, its Red Rate (the frequency of confidently swallowing a lie) is a mere 3.0%.

In the 2026 landscape, Sonnet 4.6 is the only model that behaves like a skeptic by default. It doesn’t just know facts; it understands when a premise is fundamentally flawed.

The Open-Source Challenger: Qwen3.5 Alibaba’s latest flagship has emerged as the only serious threat to the Anthropic monopoly. Qwen3.5 397b (A17b) holds a 78.0% Green Rate.

The Insight: With a remarkably low 5.0% Red Rate, Qwen3.5 is actually safer and more honest than many Western closed-source models. For developers looking for open-weights reliability, the “Alibaba Moat” is now a reality.

The Stagnation of the Giants The most uncomfortable truth in BullshitBench v2 is the performance of OpenAI and Google. Despite their dominance in creative and coding tasks, they are stuck in the 55–65% range. These models have been RLHF’d (Reinforced Learned from Human Feedback) to be so “helpful” that they have lost the ability to disagree with the user, making them a liability in high-stakes RAG (Retrieval-Augmented Generation) environments.

Quantitative Breakdown: Top Tier Performance

Based on the latest v2 data, the hierarchy of truthfulness is now clearly defined:

The Gold Standard: Claude Sonnet 4.6 (High Reasoning)
91.0% Detection Rate | 3.0% Hallucination Rate.

The Verdict: The only choice for autonomous agents in Law or Medicine.

The Elite Runner-Up: Claude Opus 4.5 (High Reasoning)
90.0% Detection Rate | 8.0% Hallucination Rate.

The Verdict: Powerfully intelligent, but slightly more prone to “creative” errors than Sonnet 4.6.

The Open-Source King: Qwen3.5 397b A17b (High)
78.0% Detection Rate | 5.0% Hallucination Rate.

The Verdict: The primary alternative to the Anthropic stack.

The Efficiency Leader: Claude Haiku 4.5 (High)
77.0% Detection Rate | 12.0% Hallucination Rate.

The Verdict: Proof that “truthfulness” is being baked into smaller, faster models.

Domain-Blindness: Bullshit is Universal

BullshitBench v2 introduced 100 new questions across five critical domains: Coding (40), Medical (15), Legal (15), Finance (15), and Physics (15). The data shows that honesty is not a “knowledge” problem; it is an architectural trait. Models that fail to detect a fake Python library in the coding section fail at a nearly identical rate when presented with a fake medical symptom. You cannot “fine-tune” honesty into a model by giving it more textbooks; you have to train it to prioritize factual refusal over user satisfaction.

Final Verdict for Developers

BullshitBench v2 is a funeral march for the “Just Add More Parameters” philosophy. In 2026, the delta between a model that looks smart and a model that is reliable is wider than ever.

For any project where a hallucination is a catastrophic failure — be it a legal researcher, a medical diagnostic aid, or a financial auditor — your choice is no longer between “GPT or Claude.” It is between Claude 4.6 and everything else.

Want to see the carnage for yourself?

Interactive Leaderboard: BullshitBench v2 Viewer(https://petergpt.github.io/bullshit-benchmark/viewer/index.v2.html)

Audit the Questions: GitHub Repository(ttps://github.com/petergpt/bullshit-benchmark)

Python QuickStart: Calling AnyAPI.ai for LLM Requests (2026 Edition)

E S — Sun, 15 Feb 2026 18:38:15 +0000

In this guide, we will explore how to use AnyAPI as a unified gateway to access the latest frontier models using the standard OpenAI Python SDK.

Architecture Overview AnyAPI.ai operates as a transparent proxy. Your code interacts with a single endpoint, while AnyAPI handles the complex routing to various providers.

Why Use AnyAPI.ai in 2026?

Instant Model Switching:
Move from OpenAI to Anthropic by changing just the model string.

Unified Agentic Workflows:
Use openai/gpt-5.2 for reasoning and google/gemini-3-pro for multimodal analysis under one API key.

‍

Setup and Configuration `Bash pip install openai python-dotenv

Configuration
Create a .env file:

ANYAPI_BASE_URL=https://api.anyapi.ai/v1
ANYAPI_API_KEY=your_anyapi_token_here
‍`

Implementation: Calling the Latest Models Synchronous Request (GPT-5)

`import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
base_url=os.getenv("ANYAPI_BASE_URL"),
api_key=os.getenv("ANYAPI_API_KEY")

Calling GPT-5 using provider/model format

)
response = client.chat.completions.create(
model="openai/gpt-5",
messages=[{"role": "user", "content": "Analyze the legal implications of AI-generated smart contracts."}]
)

print(f"GPT-5 Response: {response.choices[0].message.content}")

Asynchronous Streaming (Claude 4.6 Opus)

import asyncio
from openai import AsyncOpenAI

async def main():
async_client = AsyncOpenAI(
base_url="https://api.anyapi.ai/v1",
api_key="your_anyapi_token"
)

stream = await async_client.chat.completions.create(
    model="anthropic/claude-4-6-opus",
    messages=[{"role": "user", "content": "Architect a microservices system in Rust."}],
    stream=True


async for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

if name == "main":
asyncio.run(main())`
‍)

Model Selection Strategy for 2026

Entry-Level & High Speed:
Use google/gemini-3-flash or meta-llama/llama-3.1-405b-instruct

Professional Coding & Agents:
Use openai/gpt-5 or anthropic/claude-4-5-sonnet.

Frontier Reasoning:
Use anthropic/claude-4-6-opus or openai/gpt-5.

‍

Standardized Error Handling

Authentication Error (401):
Check your AnyAPI key.

Rate Limits (429):
Occurs if your AnyAPI tier or downstream provider is throttled.

Model Not Found (404):
Ensure the model name (e.g., openai/gpt-5) is valid in your dashboard.

‍

OpenClaw meets AnyAPI.ai: How to scrape the web without losing your mind

E S — Sat, 07 Feb 2026 11:43:28 +0000

Let’s be real for a second. Web scraping used to be a nightmare of broken CSS selectors and constant cat-and-mouse games with site updates. If you are tired of your scrapers breaking because a developer changed a div to a section, you are in the right place.

Today we are combining OpenClaw (the eyes and hands) with AnyAPI.ai (the brain). This combo lets you turn any messy website into clean JSON without writing a single line of fragile selector code.

‍

What is the deal with OpenClaw?
OpenClaw is an open-source tool that uses AI agents to browse the web just like a human would. Instead of telling it "find the third span inside the second div," you just tell it "give me the product price."

It handles the scrolling, the clicking, and the messy HTML. But to actually understand what it’s looking at, it needs to talk to a Large Language Model (LLM). That is where things usually get annoying with API keys and regional blocks.

‍

Enter AnyAPI.ai: The ultimate LLM shortcut
AnyAPI.ai is basically a universal remote for AI models. Instead of managing five different accounts for OpenAI, Anthropic, and Google, you get one key.

One billing setup:
You pay one place but get access to GPT-4o, Claude 3.5, and Llama 3.

OpenAI-compatible:
This is the best part. It uses the exact same format as OpenAI, so you can plug it into almost any AI tool by just changing one URL.

No borders:
If you are in a region where some AI providers are blocked, AnyAPI acts as your legal bridge.

‍

The 3-minute setup
First, make sure you have your API key from the AnyAPI.ai dashboard. Then, let’s get your environment ready.

‍
**

The config (The .env way)**

The cleanest way to do this is to set up a .env file. We are going to "trick" OpenClaw into thinking it is talking to OpenAI, while actually routing it through AnyAPI.

`# Redirect OpenClaw to the AnyAPI gateway
BASE_URL="https://api.anyapi.ai/v1"

` Your AnyAPI Key goes here
ANYAPI_API_KEY="your_actual_anyapi_key"

Pick your favorite model from the AnyAPI list
MODEL_NAME="gpt-4o"‍
**

The Python code**

Here is a simple script to get you started. No complex setup, just pure data extraction.

`from openclaw import OpenClaw
import asyncio
import os

We point the base_url to AnyAPI
`claw = OpenClaw(
api_key=os.getenv("ANYAPI_API_KEY"),
base_url="https://api.anyapi.ai/v1",
model="gpt-4o"
)

async def scrape_site():
# Tell OpenClaw exactly what you want
my_schema = {
"title": "string",
"price_usd": "float",
"availability": "boolean"
}

print("Working my magic...")

result = await claw.scrape(
    url="https://example-shop.com/product",
    schema=my_schema
)

!
print(f"Here is your data: {result}")

if name == "main":
asyncio.run(scrape_site())
‍``

Pro-tips for a better experience
Watch your tokens:
Web pages are full of useless code. OpenClaw tries to clean this up, but choosing a model like gpt-4o-mini on AnyAPI can save you a ton of money if you are scraping thousands of pages.

Timeouts are your friend:
AI takes a few seconds to "think" about the page content. Make sure your script doesn't time out after 10 seconds. Give it 60 to be safe.

Model switching:
If GPT-4o is struggling with a specific table, just change your MODEL_NAME to claude-4-5-sonnet in your AnyAPI settings. No code changes required.

Final thoughts
By pairing OpenClaw with AnyAPI.ai, you have essentially built a scraper that is "future-proof." Even if the website changes its entire design tomorrow, the AI will still find your data.