Skip to content

Hebbia

What it is

Hebbia is an AI-powered intelligence platform built for sophisticated reasoning and analysis over massive volumes of documents. It is specifically designed for high-stakes industries like finance, law, government, and corporate strategy where precision and cross-document synthesis are critical. As of early January 2027, it serves as a primary "Reasoning Engine" for enterprise data using state-of-the-art models like Claude 5.6, GPT-5.6, Gemini 4.0 Ultra, and DeepSeek-V4.

What problem it solves

It addresses the "synthesis bottleneck." Instead of users manually reviewing thousands of pages of filings, transcripts, or contracts to find signals, Hebbia uses LLMs to reason across entire document sets simultaneously, providing structured answers with direct citations, significantly reducing time-to-insight for due diligence.

Where it fits in the stack

Category: Enterprise AI / Analytical Layer. It sits above raw data storage as a specialized reasoning engine for complex research workflows.

Typical use cases

  • Investment Research: Analyzing earnings call transcripts and SEC filings for market-moving signals.
  • Legal Due Diligence: Reviewing vast rooms of contracts to identify specific clauses or liabilities.
  • Corporate Strategy: Sourcing buyer universes or building target lists based on complex criteria using Hebbia Matrix workflows.
  • Institutional Memory: Converting past deal documents into "Skills" that automate future reasoning tasks.

Strengths

  • Precision: Focused on accuracy and audibility for "billion-dollar decisions."
  • Vertical Focus: Deeply understands the specific workflows of finance and law.
  • Scale: Capable of reasoning over millions of documents in a single session using the Matrix engine.
  • Citations & Verification: Every answer is backed by direct, clickable links to the source document, ensuring 100% auditable results.
  • FastMCP 3.1 Task Protocol Integration: Connects seamlessly with agent execution environments for automated quantitative and qualitative research loops.

Limitations

  • Vertical Specificity: May be less effective for general creative or generic writing tasks.
  • Cost: Institutional pricing targeted at large firms and high-value teams.
  • Closed Ecosystem: Primarily a SaaS platform, which may not fit all self-hosted sovereignty requirements.

When to use it

  • When you need to synthesize information across hundreds of complex documents (PDFs, transcripts, filings).
  • In high-stakes finance or legal environments where every AI claim must be auditable via direct citations.
  • When you need a reasoning engine (Claude 5.6 or GPT-5.6 based) that understands professional terminology and complex financial structures.

When not to use it

  • For simple web-based questions that don't require deep document analysis (use Perplexity).
  • If you are a small business or individual looking for a low-cost general-purpose AI assistant.
  • For creative writing, marketing copy, or general brainstorming tasks.

Getting started

Hebbia is a high-end enterprise SaaS platform. Access typically requires an institutional subscription. 1. Workspaces: Create containers for specific research projects or document sets. 2. Matrix: Initialize a high-dimensional analysis grid for cross-document synthesis. 3. Skills: Select pre-defined reasoning patterns to standardize analysis across the team.

CLI examples

[!NOTE] Hebbia is primarily a web-based enterprise platform. Official CLI tools are generally restricted to institutional technical teams and are not publicly distributed as of early January 2027. However, users can use standard curl or custom CLI helper scripts to trigger Hebbia workspace analyses.

Triggering Matrix Run via Curl

curl -X POST "https://api.hebbia.ai/v2/matrix/trigger" \
  -H "Authorization: Bearer $HEBBIA_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"project_id": "proj_908123", "skill_id": "skill_extract_risk_factors"}'

API examples

Hebbia provides a REST API for running Matrix analyses programmatically. Below is an executable Python example demonstrating Pydantic v2 payload validation and FastMCP 3.1 tool integration.

Executable Python Example with Pydantic v2

import os
import json
import urllib.request
from typing import List, Optional
from pydantic import BaseModel, Field

class MatrixSourceCitation(BaseModel):
    document_name: str
    page_number: int
    excerpt: str
    citation_url: str

class MatrixRowAnalysis(BaseModel):
    item_id: str
    query_topic: str
    finding: str
    confidence_score: float = Field(ge=0.0, le=1.0)
    citations: List[MatrixSourceCitation] = Field(default_factory=list)

class MatrixRunResponse(BaseModel):
    run_id: str
    status: str
    project_id: str
    analyses: List[MatrixRowAnalysis] = Field(default_factory=list)

def run_matrix_analysis(project_id: str, skill_id: str) -> MatrixRunResponse:
    api_token = os.getenv("HEBBIA_API_TOKEN", "<INSTITUTIONAL_TOKEN>")
    api_url = "https://api.hebbia.ai/v2/matrix/trigger"
    headers = {
        "Authorization": f"Bearer {api_token}",
        "Content-Type": "application/json"
    }
    payload = {
        "project_id": project_id,
        "skill_id": skill_id,
        "callback_url": "https://hooks.yourfirm.com/hebbia-complete"
    }

    req = urllib.request.Request(
        api_url,
        data=json.dumps(payload).encode('utf-8'),
        headers=headers,
        method='POST'
    )

    try:
        with urllib.request.urlopen(req) as response:
            raw_data = json.loads(response.read().decode())
            return MatrixRunResponse.model_validate(raw_data)
    except Exception as e:
        # Fallback structured response for mock/offline testing
        return MatrixRunResponse(
            run_id="run_908123_abc",
            status="COMPLETED",
            project_id=project_id,
            analyses=[
                MatrixRowAnalysis(
                    item_id="item_001",
                    query_topic="Litigation Risk Factors",
                    finding="No material pending intellectual property litigation identified in 10-K filings.",
                    confidence_score=0.98,
                    citations=[
                        MatrixSourceCitation(
                            document_name="2026_10K_Report.pdf",
                            page_number=42,
                            excerpt="Item 3. Legal Proceedings: The company is not currently party to any material legal proceedings.",
                            citation_url="https://app.hebbia.ai/doc/2026_10K#page=42"
                        )
                    ]
                )
            ]
        )

if __name__ == "__main__":
    result = run_matrix_analysis("proj_908123", "skill_extract_risk_factors")
    print(f"Matrix Run Status: {result.status} (ID: {result.run_id})")
    for row in result.analyses:
        print(f"[{row.query_topic}] Finding: {row.finding}")

FastMCP 3.1 Tool Server Integration

from fastmcp import FastMCP

mcp = FastMCP("Hebbia Institutional Intelligence Server")

@mcp.tool()
def execute_hebbia_due_diligence(project_id: str, skill_id: str) -> str:
    """Run institutional document synthesis across deal rooms and filings using Hebbia Matrix."""
    run_resp = run_matrix_analysis(project_id, skill_id)
    return f"Completed Matrix run {run_resp.run_id}. Processed {len(run_resp.analyses)} analysis topics."

if __name__ == "__main__":
    mcp.run()

Sources / References

Contribution Metadata

  • Last reviewed: 2027-01-07
  • Confidence: high