Data → Information → Decision

Turn a dataset into an information service that governs itself.

Point manba at your data. It generates the query language, the agent interface, the documentation and the benchmark — then refuses to go live until it passes its own certification. It is not generative: it delivers what the data says, and every answer carries its provenance and its limits.

Try the live demo How it works

The problem

Datafacts, observations → Informationdata + context → Decisionat the point of action

Data on its own is under-specified. What makes it usable is context: what it means here, what is in bounds, which units and rules apply, what can be done next. Strip that away and you are left with numbers that look confident and cannot be checked.

Quality is the bottleneck

Decision quality is capped by information quality: accuracy, completeness, timeliness, provenance, and honest uncertainty. Most systems surface the first and quietly drop the rest.

A language is a context proxy

A domain-specific language evokes a shared frame, constrains expression to what is valid in-domain, and makes transfer repeatable and auditable. That is why manba generates one per dataset.

What it generates

Nothing here is hand-written per customer. It is derived from the data and its declared intent, and re-derived when the source changes.

A query language

Six fixed verbs everywhere — LIST, GET, COUNT, SUM, RESOLVE, HELP — plus the entities, fields and vocabulary of your domain. Learn the shape once, use it against anything.

Its own documentation

Every entity, field, permitted value and implicit filter, written out and kept in step with the data. Ask the service HELP and it explains itself.

An agent interface

An MCP endpoint plus a generated briefing that teaches a model the domain on connect. No prompt engineering, no hand-written tool descriptions.

A benchmark and a certificate

It writes test questions from its own grammar and declared intent, scores itself, and stays offline until it passes. Certification is a gate, not a badge.

Generated DSL reference: verbs, entities, fields, permitted values and runnable examples — The generated reference for one dataset — entities, fields, permitted values, the filters applied by default, and examples that run.

What a consumer actually gets

Ask for a total and most systems hand back a number. This one hands back a number that tells you how much of the question it answered.

A SUM result: 441.9 KB across 3 of 19 rows, with warnings, coverage bar, source default and provenance — A real result from the sample dataset. The total is 441.9 KB — and it says plainly that 16 of the 19 matching rows carry no size at all, so the figure covers 3 rows, not 19.

It declares what it filtered

Trashed files were excluded, because that is what a Drive user sees. The rule and its reasoning travel with the answer instead of hiding in someone's SQL.

It refuses instead of guessing

Ask for a field that does not exist and you get the valid fields and the nearest match — as data, not a stack trace. Wrong answers are more expensive than refusals.

The same question keeps its answer

Results are pinned to an immutable epoch, so a link to a query still returns what it returned when it was quoted. A number in a report stays checkable.

Built for the things that will consume it

Connect a model and it is briefed by the service itself, not by a prompt somebody tuned. It learns the entities, the vocabulary and the house rules on connect — then queries rather than speculates, and passes on the caveats it is given.

Asked how much storage a Drive used, a model connected this way volunteered which rows had no value and why, and named the filter that had been applied by default. Nobody asked it for caveats; they arrive attached to the answer.

> SUM FILES SIZE_BYTES

441.9 KB  (452,500)
total across 3 of 19 rows

16 rows have no SIZE_BYTES and
contributed nothing to this total.

epoch 1 · source gdrive:files
default: TRASHED IS "no"

How it works

schema discoverydomain modelgrammar context layersbenchmarkcertification gate

Six stages, run in order, ending in a gate it has to pass on its own evidence. When the source changes, the pipeline re-runs and opens a new epoch; earlier epochs stay readable, so nothing that was already quoted changes underneath the people who quoted it.

Context prepares the ground. Protocol commits the meaning.

Open ingress, disciplined commitment: people arrive in plain language, and the service funnels them into the working distinctions of the domain before it commits to an answer.

Architecture: consumers query a generated interface over an immutable snapshot, with one explicit path to live files — What is actually being queried: an immutable snapshot with a generated interface over it. Reaching a live file is a separate, explicit, clearly non-deterministic step.

Where this is

manba is a working prototype, not a product you can buy yet. It mounts CSV, Postgres and Google Drive today, generates and certifies end to end, and serves both people and agents from the same governed language.

prototype — the interesting part is the method, and the method is what these pages show.

Try the live demo See what a consumer gets