How LakehouseBox works
Your agent does the analysis.
Your box keeps the data.
Connect your agent, work with open tables, and pick up where you left off.
Beta · one site in Nuremberg, Germany · 5 GB free, no card
Your environment
01Connect
Approve your agent's connection once in the browser. It receives its own revocable key, scoped to one catalog.
02Analyse
Use DuckDB where your agent already runs. It reads the Parquet files directly; nothing runs on our side but the catalog calls.
03Keep
Save results as a new table for your next session or a teammate. A CREATE TABLE … AS SELECT in DuckDB is one Iceberg commit.
See the commands
# the agent, on its machine lhbox login # prints a link and a code; the person approves once in the browser lhbox duckdb # the DuckDB shell with the catalog attached (the recipe is never on screen) lhbox connect --engine duckdb # or a paste-ready recipe: duckdb | pyiceberg | spark -- inside DuckDB SELECT product, sum(revenue) FROM demo_data.sales.orders WHERE day >= current_date - 7 GROUP BY 1; CREATE TABLE demo_data.analytics.weekly_sales AS SELECT …; -- one Iceberg commit; another session can open it
The approval flow. lhbox login prints a link (/app/device?user_code=XXXX-XXXX) and the code, opens the browser when there is one, and waits up to 15 minutes. The person sees this machine's name, the catalog and the access asked for (read and write by default; they may lower it to read only) and approves. The CLI receives the key of a new agent of their organisation, named after the machine and holding exactly the approved access, saves it and never prints it. A person with no account yet creates one on the same page. When login cannot block: lhbox login --no-wait, send the link, later lhbox login --resume. Running login again on a connected machine answers Still connected.
The connection. The catalog is an Iceberg REST catalog with its own S3-compatible bucket. lhbox connect prints, per engine, the catalog URL, the bucket and the catalog's credential filled in; lhbox duckdb passes the same through a private init file. Several catalogs: lhbox catalog list, then --catalog <name>. The full page an agent follows: Agent setup.
The recorded run (2026-09-20, live service): DuckDB 1.5.5 on a laptop read a 185,884-row table, pivoted it into 61 rows in 363 ms and saved the result as a new table in 1,231 ms; a second process attached and read it back 340 ms later.
The session ends.
The data stays.
Your tables live independently of any one agent session, maintained whether or not anyone is connected.
✓ Saved to LakehouseBox
Ready to analyse
A clear division of work.
Your agent + engine
- ▷Run queries
- ≡Read and write tables
- ✓Choose what to save
You bring the compute: DuckDB in the agent's process, PyIceberg in a script, Spark on your cluster. There is no query endpoint on our side and the MCP server has no query tool, by design.
LakehouseBox
- ◫Catalog and storage
- ⚿Scoped access
- ⟳Table maintenance
- ▦Persistent results
One system, in Nuremberg, Germany: the Iceberg REST catalog and the object store together. Every catalog is its own bucket with its own storage identity.
Your engine accesses the catalog and storage directly. Rows travel between your engine and the object store; LakehouseBox sees the catalog call and the object reads, never a result set.
How access and credentials work
People sign in on the account page with email and password. Agents connect with lhbox login, approved once in a browser, or are given an agent key by an administrator; every key is revocable on its own and scoped to one catalog at read or write level.
Short-lived credentials do the work. The engine exchanges the catalog's credential for catalog tokens that live 900 seconds and for per-table storage credentials that live about an hour, by itself, on every request. A credential for one catalog cannot list, read or write another: the boundary is enforced by the catalog and the object store, not by our application code, and the isolation suite proves it with a positive control on every run.
Direct reads. Data files are read straight from the object store over HTTPS with those credentials. Public catalogs (the public data) are readable with no credentials at all, at the storage level; their catalog endpoint stays private.
The contract in full: the docs, "Permissions and access". Security notes: Security.
What table maintenance includes
Hourly, for every table, whether or not anyone is connected: compaction of small files, snapshot expiry (20 snapshots and 7 days are kept, so time travel reaches back that far) and orphan-file cleanup. Maintenance commits are optimistic like any other: a client committing at the same moment gets a conflict and retries.
Recovery. Off-host copies run every 5 minutes for accounts and grants, hourly for table metadata and nightly for data files; the restore is rehearsed (about 35 minutes the last time).
Beta, said plainly: one host, no automatic failover, no SLA yet; a host failure means downtime until a restore. Paid plans, high availability and encryption at rest are not yet offered. What is live, with its status: Capabilities.
Open tables. Your choice of engine.
Start with DuckDB. Use other engines as your workflow grows: the catalog is a standard Iceberg REST catalog and the storage is S3-compatible.
Verified, read and write: DuckDB, PyIceberg, Spark. Recipes, not yet verified: Trino, ClickHouse. Snowflake connects but its data path does not work yet. Databricks is untested.
Versions and limitations
| Engine | Status | Notes |
|---|---|---|
| DuckDB 1.5.5+ | read and write, verified | every phase of the integration suite; 1.5.5 also writes format version 3 |
| PyIceberg 0.12 | read and write (format version 2), verified | reads version 3, cannot write it |
| Spark 3.5 + Iceberg 1.11 | read and write, version 3 included, verified | 2026-09-20, with a geometry column |
| Trino, ClickHouse | recipe from the REST contract, not yet verified | no recorded run against the service; the docs say so until there is one |
| Snowflake | catalog integration connects; data path not yet | needs work on both sides |
| Databricks | untested | no run, no recipe |
Tables are Iceberg format version 2 by default; a table can be created as version 3 (geometry and geography columns) and DuckDB 1.5.5+ and Spark write it. One command, lhbox connect --engine duckdb|pyiceberg|spark, prints the recipe with the credential filled in. Every recipe, its verification date and its gotchas: Engines.
What makes it a lakehouse?
A catalog names the tables. Apache Iceberg records which Parquet files make each one up, its schema and every version of it. The files stay open, in a bucket you can list, and any engine that speaks Iceberg can open them.
Files become tables
A data lake is a collection of files, usually Parquet, in object storage: cheap, readable by any tool, but nothing says which files make up a table or what changed last night. A lakehouse adds a table format and a catalog. The table format records which files belong to a table, its schema, its partitioning and every version; the catalog is where engines ask which tables exist and where the current version of each one is.
In LakehouseBox the hierarchy is organisation → catalog → namespace → table. A catalog is one Iceberg REST catalog with its own bucket; a namespace is a schema. The engine sees demo_data.garden.sensor_readings.
Changes have a history
Atomic commits. A write becomes visible in one step or not at all. A second commit against a stale version is refused and retried; a table is never half updated.
Snapshots and time travel. Every commit is a snapshot, and an engine can read the table as it was before the last load. Maintenance keeps 20 snapshots and 7 days per table.
Schema evolution. Columns can be added, renamed, widened or dropped without rewriting the data files.
Your data uses open formats
Many engines, one table. The same table is read by DuckDB, PyIceberg and Spark today, and by any engine that implements the specification. The engine is a choice, not a commitment.
The data is yours to take. A table is Parquet files plus JSON and Avro metadata in a bucket you can list. Copy it out with standard tools at any time; there is no export format to convert from. The software we run to serve it is open source and named on the sovereignty page.
A place for your data.
Compute on your terms.
We meter storage. You bring query compute.
5 GB free · No credit card · Beta, no SLA · Self-hosting available
Limits, retention and what maintenance includes
One thing is metered: how much you store, measured hourly and on demand. Not queries, not commits, not rows, not egress. Query compute runs in your environment, so there is nothing of ours to charge for it. Table maintenance (compaction, snapshot expiry, orphan cleanup, hourly) costs a fraction of a cent per gigabyte processed and is included, not metered.
Today's offer is the free plan: 5 GB stored, no card. Paid plans are not yet announced; public data gets its own tier (50 GB, coming soon). The other limits are guards, not prices: catalogs per project, snapshot history at 20 snapshots and 7 days. The API tells you each limit and its headroom before you reach it.
Limits and how storage is measured: the docs. The plan and the beta conditions: Pricing.