Intelligible — the team behind elbi — is part of TechCrunch Disrupt's 2026 Startup Battlefield 200
elbi

elbi — Empirical Layer by Intelligible

Data science is iterative. Your agent's data understanding should be too.

Every hypothesis a data scientist checks gets discarded when the session ends. elbi turns each checked result into a derivation: a cached, certified MCP tool that remembers what was found, so the next agent builds on it instead of guessing again.

This is the Empirical Layer by Intelligible (ELBI): a memory layer built from what's actually been verified, not just named. Runs on your machine — no platform to lock you into.

Get startedView on GitHub

Your data

Tables & files

CSV, Parquet, SQL

Definitions

semantic layers, ontologies

Empirical layer

statML registry

Human-written

Agent-written

Your agent

Claude Code, Cursor, yours

elbi, at rest in the empirical layer

Built by the team behind Intelligible

  • Apache-2.0, all of it
  • ·runs on your machine
  • ·no lakehouse required
  • ·any Python model or metric
  • ·works with any MCP agent

§ 01 · Premise

Give an agent raw SQL access and you've hired a confident guesser.

It re-derives the join, the threshold, the definition of “active” a little differently every time — and none of it survives the session. The next agent starts from zero and pays to guess again.

An empirical layer fixes that: compute once, certify once, keep it forever. Read what that actually means.

§ 02 · Anatomy

A plain function. A signed certificate.

Declare the inputs and how to serve the result. elbi runs the function against the data you bound and caches the output until the code or data changes.

@derivation(
    inputs={"sales": Dataset("sales")},
    serve=serve.table(title="Churn risk", max_rows=50),
)
def churn_risk(ctx: Context) -> Artifact:
    """Per-customer churn-risk scores."""
    rows = ctx.input("sales").rows
    scored = [
        {"customer_id": r["customer_id"],
         "risk": 1 / (1 + float(r["amount"]))}
        for r in rows
    ]
    return Artifact.table(scored)
  • i.

    Provenance

    Every run is recorded in the derivation's result history: what changed, and what moved it.

  • ii.

    Portability

    Served over MCP to any client — Claude Desktop, Cursor, the MCP Inspector, or your own agent.

  • iii.

    Trust

    A derivation reads the same either way — person or agent. elbi verifies it under isolation; a human certifies it before it serves.

  • iv.

    Memory

    Hand an agent a model you trust, or let it propose one from your data — either way. Once certified, it stays: durable, not gone when the session ends.

See the full pipelineWhat is an empirical layer?Read the Open Derivation Spec

Verification certificate

Verified

churn_risk@v3

Bound inputs

  • sales.customer_id
  • sales.amount
  • sales.recency_days

Certified by

you@company.com

Signature

3f9a1c…e02d

§ 03 · Quickstart

One install. No key required to start.

elbi serve opens a local web app: a chat UI, a SQL workbench, notebooks to promote a cell straight to a certified derivation — this is where you review and certify. The same server exposes it all over MCP at localhost:7700/mcp. Want just the MCP endpoint? Install elbi-cli alone.

Read the getting-started guide
$ uv tool install elbi
$ elbi init example-project
$ cd example-project
$ elbi serve

First run takes ~15–20s longer while it warms up. That's expected, not a hang.

§ 04 · What it does

What changes once agents call derivations, not tables.

01 · Reuse

Pay for the computation once. Every later prompt is free.

A derivation runs the expensive part once. Every later prompt gets the cached result back in milliseconds.

First call

1.4s · full scan + join

2nd call

4ms · cache hit

1,000th call

4ms · cache hit

02 · What it can touch

Your agent doesn't get your database. It gets an answer.

Point Claude Code, Cursor, or your own agent at a derivation instead of raw tables — a typed result, not a hallucinated join.

Claude Code

Cursor

your agent

run_derivation

03 · Certification

It doesn't serve until a person signs off.

Agents can propose a derivation. elbi verifies it in isolation and serves it only once a person signs off.

04 · Auditability

Every cached answer traces back to a derivation and a version.

Each one keeps a result history and an exportable, offline-verifiable certificate. Built for teams that have to show their work.

response.jsoncertified

cite: churn_risk@v3

cite: monthly_active.segment@v1

cite: revenue.forecast@v2

05 · Scales when you need it

Local-first for one person. Shared for a team.

elbi is Apache-2.0 and runs on your machine — nothing leaves your network unless you point it there. elbi-enterprise layers SSO and tenant isolation onto the same build when a team needs it.

You, aloneelbi
→
Your teamSSOgroups & grantsSCIMKubernetes
↘ same build, no fork, no migration

§ 05 · Workflow

Three steps, no model training required.

STEP 01

Write

Bind data from a CSV, Parquet, or SQL database. Write a derivation as a plain Python function with declared inputs and an output format.

STEP 02

Certify

Certify it yourself, or let an agent propose one first — elbi verifies it under isolation before anything serves.

STEP 03

Serve

elbi caches the result and serves it as an MCP tool to any client, recomputing only when code or data changes.

Get started

Point elbi at your data. Ground your agents in minutes.

No account, no fine-tuning, nothing that leaves your network unless you point it there. Bring the model you've already built — it computes once, stays cached.

Get startedHow it works