Higher Than GPT-5? We Attempt ERNIE X1.1, Baidu’s Newest AI Mannequin

Take: The construction seems neat. Headings keep disciplined. Desk formatting holds.

Picture technology: reasoning-guided structure and variant management

• Aim: Design a 1080×1350 occasion poster, then create a clear variant.
• Why this issues: I count on ERNIE X1.1 to plan earlier than rendering. Reasoning ought to information instrument calls.

Immediate:

“Design a 1080×1350 poster for ‘Information + Dharma 2025’. Mix a skyline, a temple silhouette, and a circuit board sample. Place the hero title top-center. Put the subtitle bottom-left. Place sponsor logos bottom-right. Maintain distinction excessive and textual content readable on cellular.”

Observe-up immediate:

“Create a second variant. Change subtitle to ‘Historical Concepts. Fashionable Intelligence.’ Maintain structure equivalent. Enhance brand padding by 12 pixels.”

Output:

Take: ERNIE X1.1 clearly failed right here. It looks like the mannequin couldn’t handle the nitty-gritties of the immediate, and took a very long time to give you a completely garbage output.

Code Era: FastAPI service for hallucination threat

• Aim: Ship a tiny service that scores hallucination threat. Embrace unit checks.
• Why this issues: I need scaffolds that run on the primary attempt. ERNIE X1.1 ought to ship a clear construction.

Immediate:

“Write a Python FastAPI service /threat that accepts {textual content, sources[]} and returns hallucination_risk in [0,1]. Use lexical overlap and a easy contradiction test. Embrace pytest unit checks. No exterior SaaS calls. Maintain it production-readable.”

Output:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Listing

app = FastAPI()

class RiskRequest(BaseModel):
    textual content: str
    sources: Listing[str]

class RiskResponse(BaseModel):
    hallucination_risk: float

def calculate_lexical_overlap(textual content: str, sources: Listing[str]) -> float:
    """Calculate Jaccard similarity between textual content and sources"""
    text_words = set(textual content.decrease().break up())
    total_similarity = 0.0
    valid_sources = [s for s in sources if s.strip()]
    
    if not valid_sources:
        return 0.0
    
    for supply in valid_sources:
        source_words = set(supply.decrease().break up())
        intersection = text_words & source_words
        union = text_words | source_words
        similarity = len(intersection) / len(union) if union else 0
        total_similarity += similarity
    
    return total_similarity / len(valid_sources)

def calculate_contradiction(textual content: str, sources: Listing[str]) -> float:
    """Easy NLI-inspired contradiction detection"""
    if not sources:
        return 0.0
    
    negation_words = {'not', 'no', 'by no means', 'none', 'with out'}
    contradiction_count = 0
    
    for supply in sources:
        source_tokens = supply.decrease().break up()
        text_tokens = textual content.decrease().break up()
        
        # Test for direct contradictions
        for i, token in enumerate(text_tokens):
            if token in negation_words and that i+1 

Early Impressions

Right here is my trustworthy take thus far – ERNIE X1.1 thinks quite a bit. It second-guesses many steps. Easy duties typically set off lengthy inner reasoning, slowing simple outputs that you just count on to be fast.

On some prompts, ERNIE X1.1 feels overcautious. It insists on planning past the duty. The additional considering typically hurts coherence. Quick solutions turn into meandering and not sure, identical to a human overthinking.

When ERNIE X1.1 hits the groove, it behaves nicely. It respects format and part order, and may hold tables tight and codes neat. The “suppose time,” although, typically feels heavy.

In my future use of it, I’ll tune prompts to curb this by decreasing instruction ambiguity and including stricter constraints. For on a regular basis drafts, the additional considering wants restraint. ERNIE X1.1 reveals promise, however it should tempo itself.

Limitations and Open Questions

Entry exterior China nonetheless includes friction on cellular. ERNIE X1.1 works greatest by means of the net or API interface. Pricing particulars stay unclear at launch. I additionally need exterior benchmark checks, as the seller claims on the time of launch sound too daring to be correct.

The “considering” depth wants consumer management. A visual knob may assist on this regard. If it had been to me, I might add a quick mode to the mannequin for all these fast drafts and emails. Then once more, a deep mode for brokers and instruments could be useful as nicely. ERNIE X1.1 can profit from clear distinctions.

Conclusion

ERNIE X1.1 goals for reliability, not flash. The declare is fewer hallucinations and higher compliance. My runs present sturdy construction and respectable code. But the mannequin typically overthinks. That hurts pace and coherence on easy asks.

I’ll hold testing with tighter prompts. I’ll lean on API paths for brokers. If Baidu exposes “suppose” management, adoption will rise. Till then, ERNIE X1.1 stays in my toolkit for strict drafts and clear scaffolds. It simply must breathe between ideas.