Your agent shouldn't write your API layer. One binary serves it.

We've all become merchants of complexity. We just outsourced the manufacturing to a model.

Prompt, generate, handler. Prompt, generate, tests. Prompt, generate, tools. Per table, per service, per company. It's never been easier to produce code and never been harder to say what any of it is for. We industrialized the one thing software was supposed to eliminate: busywork.

We wanted no part of it.

One binary. Every table is an API.

Minimal Core: one binary. Drop it on the database you already have. Every table is a REST API and an MCP tool. Permissioned. Audited. Nothing generated, nothing scaffolded, nothing "quietly" written for you. No code, because the right amount of code for this layer is none.

The moment it starts, you have:

• A REST API for every table, with permissions set per table and per verb.
• An MCP tool for every table, so an agent works with the same data under the same rules. That is 115 tools in all: read and write tables, govern them, build APIs.
• An audit trail of every call, from people and agents alike.
• No handler code. Definitions live in a Postgres store and requests are answered from them. There is nothing to generate, test or review, so there is nothing to defend.

Your agent stops writing the API and starts asking for it.

Three of us have built toward this for years. Minimal Core is in beta today.

Run it today

Start here: the lean stack, three containers and five commands

littlebitlabs / minimal-setup

Guides and scripts to run Minimal, Relay and Postgres with Docker Compose, plus an MCP guide and test script

Minimal setup

Your data already lives in a database. Minimal turns it into a governed API platform: point it at your tables and you get REST endpoints you didn't have to write, permissions per table and per verb, an audit trail of every call — and an MCP server, so AI agents can work with the same data under the same rules. This repository is the shortest tested path to running it yourself: three containers, five commands, about ten minutes. Every command in it was run before it was written down; the few that weren't are marked (not tested).

Quick start

This is Docker Compose on your own machine — case 2 of the setup table below, and the path to start with. You need Docker with Compose v2, python3 and openssl, and a Minimal license. The license is self-service: sign in to the license portal with Google…

View on GitHub

Or the full stack from one compose file: sign-in, gateway, TLS and a sample app

littlebitlabs / minimal-pitstop

Minimal with sign-in, an API gateway, TLS, sample data and a sample app, from one Docker Compose file. Guides and AI-agent setup skills.

Minimal Pitstop

Minimal turns database tables into a governed REST API: roles and permissions are enforced on every call. Pitstop runs it with everything it needs from one Docker Compose file: sign-in, an API gateway, TLS, a sample dataset and a sample app. One docker compose up -d --wait, then a tour that checks it works.

This repo holds the compose file and the guides, mirrored byte for byte from the Littlebit Labs artifacts registry. It has no source.

Before you start

• Docker (Engine 26+, Compose 2.17+) on Linux or macOS.

• A Minimal license, self-service. Sign in to the license portal with Google or GitHub; the free trial needs no card and ends in a hard stop, never an invoice. On the License page download the key file minimal-license-<slug>.json and copy the LICENSE_SECRET (shown once; Replace secret gives you a new one). On the Account page note your…

View on GitHub

What changes for the agent

Before: prompt, generate a handler, generate its tests, generate a tool wrapper. Then the next table.

After: it connects, lists the tools and uses them.

curl -X POST http://127.0.0.1:3046/minimal/mcp/rpc/v1 \
  -H "LB-Access-Token: <token>" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

That call returns all 115 tools. The agent works with exactly the permissions its token carries, and every call is recorded. Minimal speaks MCP, so any MCP client (Claude, ChatGPT, Codex, Cursor and so on) can connect.

What goes back in your pocket

• Tokens. The 90% of tokens you burned on CRUD plumbing go back in your pocket. That figure is ours, from our own tasks, not an independent benchmark. Test it on yours.
• Time. The weeks your team spent babysitting that layer go back on the calendar.
• Trust. The more autonomous your agents get, the more trust has to be built in, not bolted on. Here, permissions and audit are the foundation, not a feature added later.

Try it in about ten minutes

You need Docker with Compose v2, python3, openssl and a Minimal license. The license is self-service: sign in to the license portal with Google or GitHub and download two files.

One catch first. The license relay checks in with the Littlebit license server every time it starts, and the server only answers addresses on your Relay access list. Find yours and add it in the portal:

curl -4 -s https://checkip.amazonaws.com

Then:

git clone https://github.com/littlebitlabs/minimal-setup.git
cd minimal-setup/compose

./setup.sh <slug> /path/to/minimal-license-<slug>.json \
  /path/to/minimal-license-secret-<slug>.json
./fetch-binaries.sh      # each download is checked against a pinned SHA-256
docker compose up -d --build

curl http://127.0.0.1:3045/minimal/proof/v1/ping      # expect: "message":"pong"

That is three containers: minimal, postgres and relay. Only minimal publishes ports, and both are bound to 127.0.0.1.

To get an agent token, the repo ships a script that creates a sample org and a 7-day token, then proves every tool family against your running stack:

python3 compose/tests/mcp-proto.py

What to know before you try it

• It's a beta. A trial license is for evaluation: you can connect a production database to try it, but not to serve production traffic.
• It's closed source. There is no open-source license in the repo. Your use is governed by your Minimal license agreement and Littlebit's terms.
• It phones home. The relay needs outbound access to relay.license.littlebitlabs.com on port 443, from an address on your allow list. If your address changes, you add the new one.
• It speaks plain HTTP. Fine on loopback on one machine. Across a network, use an SSH tunnel. Docker publishes ports through its own firewall rules, so ufw alone won't restrict them. The compose guide has the details.
• Tested on: Minimal v0.62.13-2-g2b26815 and Relay v0.2.3, on an Apple Silicon Mac and on Ubuntu 24.04 (x86-64). Other versions and platforms may differ.
• Not tested yet: MCP through an SSH tunnel, and the agent setup skill end to end.

If you would rather hand-write your API layer, or you need the whole stack to be open source, this isn't for you, and that's a fair answer.

Get it

github.com/littlebitlabs/minimal-setup: the lean stack, three containers, five commands.

github.com/littlebitlabs/minimal-pitstop: the full stack from one compose file, with sign-in, a gateway, TLS, 10 sample datasets, a sample app and a tour that checks it all works.

The beta has a free tier of 60 days and 3 million requests, no card. Get your license at license.littlebitlabs.com.

A question for you

When your agents need an API over your own data today, what do you do: let them generate it, write it yourself, or something else? And what would you need to see before you trusted a layer you didn't write?