GenHTTP Lambda Community edition

Every app your agent builds, online on your own server.

GenHTTP Lambda is a self-hosted home for the small apps you build with Claude Code, Codex or Cursor. Connect your agent once over MCP, and every app it makes is online seconds later at an address of its own, with a database, versions and visitor stats. You look after one container.

$ docker run -d -p 8080:8080 \
    -v lambda-data:/data \
    -e LAMBDA_ADMIN_TOKEN=a-long-password \
    genhttp/lambda

Then open http://localhost:8080. That is the whole setup.

  • Open source, MIT
  • No database server
  • amd64 and arm64
Claude Code

Build a shared task list for the team, with a due date on every task.

  1. create_lambdatasks
  2. enable_datadatabase
  3. write_code7 files
  4. check_codeno errors
  5. deployversion 1 online

Team tasks is online at lambda.example.com/lambda/tasks/. Your editor link is below. Keep it safe: it is the key to the app.

lambda.example.com/lambda/tasks/

Team tasks

Add a taskAdd
  • Book the room for the retroToday
  • Send the release notesFri
  • Order the new badgesDone

Writing an app now takes minutes. Hosting it still takes the evening.

An agent writes a booking page or a webhook receiver before your coffee is cold. Then it needs a place to live, and every app needs that place again.

Every app, until now

  • Build a container image for it
  • Find a free port
  • Add an entry to the reverse proxy
  • Set up a database and its credentials
  • Remember to back it up
  • Do it all again for the next one

Every app, with GenHTTP Lambda

  • Ask your agent for it
  • It is online at its own address, with its own database
  • Every change is tried in a draft, then put online
  • One folder to back up, for all of them
  • The next app costs no new container, port or proxy entry

All apps run inside one process, which is what makes hundreds of them cheap. genhttp.dev runs this same code and serves more than a hundred apps that way.

From a sentence to an address in three steps

  1. Start the server

    One container and one volume, on a VPS, a NAS, a home server or your laptop. Set an admin password for the panel at /admin.

    $ docker run -d -p 8080:8080 \
    -v lambda-data:/data \
    -e LAMBDA_ADMIN_TOKEN=a-long-password \
    genhttp/lambda

  2. Connect your agent

    Your agent gets the platform as tools over MCP. Do this once; from then on it can create and change apps from any project.

    Run this once in a terminal.

    $ claude mcp add --transport http genhttp http://localhost:8080/mcp

  3. Ask for an app

    The agent creates it, puts it online and gives you two links: the app's address, and its editor link. Keep the editor link safe. It is the key to the app and cannot be recovered.

    Build a guestbook, with a page where I approve the entries.
    Later: Let people add a photo to their entry. The change is tried in a draft first, with a copy of the entries.

The apps that never got hosted

The ones where hosting them was more work than writing them. Ask for any of these in a sentence.

At home

  • A chore list for the family, with who did what this week
  • A recipe box everybody in the house can add to
  • A countdown page for the holidays

For a team or a club

  • A booking page for the club's court
  • A sign-up sheet for the summer party
  • A page for the event, with the agenda and the map

For your automations

  • A webhook receiver that keeps what it was sent
  • A dashboard over an API you use every day
  • A small API your scripts call, with tools for agents

Just for fun

  • A poll that updates while people vote
  • A guestbook for your site
  • A multiplayer game for friends, live in the browser

Or start from a demo: records behind an API, accounts with a login, file uploads, live updates and a websocket game ship with every installation, ready to copy and change.

What every app gets

Everything a small app needs to live on, built in, so neither you nor your agent has to set it up.

Made for agents

Any agent that speaks the Model Context Protocol connects with one address and gets the whole job as tools: create an app, write its code and check that it compiles, try a change on a copy, put it online, read the logs with their stack traces.

The agent reads what each app is for and why it was built the way it was, from documentation it keeps with every version, so the next change starts where the last one ended.

Your apps can speak MCP too: give one a few tools, and agents can use it.

Tools your agent gets

Build
create_lambdawrite_codechange_codecheck_codedeploy
Change safely
create_featuremerge_feature
Keep data
enable_dataread_databaseupload_filelist_secrets
Watch it run
read_logsanalyticsread_lambda

The same over a REST API, described in OpenAPI, and over git.

Drafts and versions

A change to an app that people use is made in a draft: a copy of the app and of its data, with a link of its own to try it. When it works, put it online. Nothing your visitors see breaks while the agent is still at it.

Every version says what changed and why, in the words of whoever asked for it. Any earlier one is one click away.

Draft: Due dates

Every task should say when it is due.

Try itPut online
  1. 2Named the list “Team tasks”Online
  2. 1Started from the demo “Keep track of things”Roll back

Records, files, keys and passwords

Each app can have a database of its own for its records, readable in the editor, and a folder for what people upload. Both outlive every version, so going back never loses data.

Keys for the services an app talks to are sealed on your server. The agent says which ones it needs; you enter them in the editor. Nobody reads them back, the agent included.

Records: tasks

titleduedone
Book the room for the retroNov 13no
Send the release notesNov 14no
Order the new badgesNov 10yes

Keys and passwords

  • WEATHER_API_KEYSet, never shown
  • GITHUB_TOKENThe app waits for itEnter

Visitors, without cookies

Switch it on for an app and see visitors, page views, the pages people open, where they came from, their countries, devices and browsers. Counted on the server, in front of the app: no cookie banner, no script in your pages, no third party.

Crawlers are counted apart, by kind: search engines, AI crawlers, link previews. Where Google, Bing, OpenAI, Apple or Perplexity publish their addresses, a visit only counts as theirs when it really came from them.

Visitors412
Page views1,038

Visitors per day

Where visitors come from

  • google.com131
  • Typed in, a bookmark or an app94
  • github.com54

And also

Git for every app
Clone it, push a commit to save a version, push with -o deploy to put it online, push a branch to start a draft.
Logs
What the app printed and how it answered, request by request, for you and for the agent that fixes it.
Addresses and domains
Apps answer below /lambda/ on your server, at subdomains of their own once you give it a domain, and at a domain of their own when you make them premium.
Live updates
Websockets and server-sent events, for pages that change while they are open: polls, dashboards, games.
A way out
Download any app as an ordinary .NET project with a Dockerfile and run it anywhere. Nothing ties it to your server.
An editor for people who don't code
Hand an app to somebody else: a simple view shows what it does, its records and its history, without a line of code. With the build agent, they ask for the next change themselves. In 13 languages.
The admin panel
Every app on the server with its traffic and errors, the limits of free and premium apps, blocks and the log.
Showcase and published source
List the apps you are proud of on your server's showcase, and publish the code of any of them under a license you pick.

Yours to run

The server, the editor, the API and every app share one process and one folder. Running it is about as much work as running a single app.

docker-compose.yml

services:
  lambda:
    image: genhttp/lambda:latest
    ports:
      - "8080:8080"
    environment:
      LAMBDA_PUBLIC_URL: https://lambda.example.com
      LAMBDA_ADMIN_TOKEN: a-long-password
    volumes:
      - lambda-data:/data
    restart: unless-stopped

volumes:
  lambda-data:
The settings you are most likely to need
LAMBDA_PUBLIC_URLWhere you and your agents reach the server. The apps' addresses are made from it.
LAMBDA_ADMIN_TOKENThe password of the panel at /admin. Without one, the panel is off.
LAMBDA_HOSTING_URLA domain for the apps, such as https://apps.example.com. Each app then gets a subdomain. Needs a wildcard DNS record and certificate.

Limits, logging, TLS, analytics and the build agent are in the reference.

HTTPS
Put it behind the reverse proxy you already use, Caddy, nginx or Traefik, with one entry for the whole server. Or let it serve TLS itself.
Backups
Everything is in the volume at /data: every version of every app, their records, files and git history. Back up the whole volume and keep secrets.key with it; without it, the stored keys and passwords cannot be read.
Updates
docker pull genhttp/lambda and start it again. The database is brought up to date as the server starts; your apps and their data stay as they are.
Hardware
Images for amd64 and arm64: a small VPS, a NAS, a home server or a Raspberry Pi with a 64-bit system.

Good to know before you start

Apps run inside the server

That is what makes hundreds of them cheap. Their code is checked for what it must not do before it runs, but it shares the server's process: this is no sandbox. Run code you would run yourself.

By path, apps share the platform's address

Below /lambda/, a page of an app could read what the editor and the panel keep in your browser. That is fine for apps you and your team build. To host apps of people you don't know, give the apps a domain with LAMBDA_HOSTING_URL, and each becomes a site of its own.

Unused apps are taken offline

A new app is free: one that nobody visits or changes for 30 days goes offline, and is removed 90 days later. Make an app premium in the panel to keep it for good, or change the durations under Limits.

Frequently asked questions

Do I need to know C#?

No. Every app is a small C# program on the GenHTTP web server, and your agent writes it. The code is there whenever you want to read or change it, in the editor or in a git clone.

Which coding agents work with it?

Any agent that can add a remote MCP server: Claude Code, Cursor, VS Code with GitHub Copilot, Codex, Windsurf, Zed and others. Claude on the web and on the desktop connect as a custom connector, which needs an address reachable from the internet. Agents that prefer HTTP or git can use the REST API or clone the apps instead.

What does it cost?

Nothing. GenHTTP Lambda is open source under the MIT license. The optional build agent uses your own Claude subscription.

What does the server need?

Docker, one port and one volume. There is no database server: the platform and every app keep their data in SQLite files. Images are built for amd64 and arm64.

How is it different from genhttp.dev?

genhttp.dev is a hosted installation of the same code. The community edition has the same features, the build agent included, and runs on your server, so the apps and their data stay with you.

Can an app have its own domain?

Yes. Apps answer below /lambda/ on your server by default. Set LAMBDA_HOSTING_URL and each app gets a subdomain of its own; make an app premium in the panel and it can have a domain of its own.

How do I back it up?

Back up the volume mounted at /data. It holds the platform's database, every version of every app, their records, files and git history, and secrets.key, without which the stored keys and passwords cannot be read.

Can I host apps for people I do not know?

Apps run inside the server's process. Their code is checked before it runs, but this is no sandbox, so run code you would run yourself. For apps of other people, give each app a subdomain with LAMBDA_HOSTING_URL so it cannot read what the editor and the panel keep in the browser.

What happens to apps nobody uses?

A new app is free: if nobody visits or changes it for 30 days it is taken offline, and removed 90 days after that. Make an app premium in the panel to keep it for good, or change these durations under Limits.

Give your agent a place to put things.

$ docker run -d -p 8080:8080 \
    -v lambda-data:/data \
    -e LAMBDA_ADMIN_TOKEN=a-long-password \
    genhttp/lambda