Instant SECURE Full Stack Apps and AI Agents
Turn plain English into a working full-stack app — database, secure API, business logic, and frontend — running on your own hardware, with zero lock-in. An open-source alternative to Lovable, Bolt44, and Replit that gives you the whole backend, plus an MCP server that turns every endpoint into a tool for Claude, Cursor, or Codex. Read more about Hyperlambda.
Run it in 60 seconds
curl -fsSL https://hyperlambda.dev/docker-compose.yaml | docker compose -f - up
Then open localhost:5555, point it at localhost:4444, and log in with root / root.
Point the API Wizard at your database, and it generates a complete, secured REST API — then extend it in plain English, without a build or deploy step.
⭐ If this saves you time, star the repo — it's the main way other developers find it.
What you can build
- Full-stack business apps — CRM systems, admin panels, booking systems, internal tools; database, secure API and frontend generated from natural language
- Database-driven AI agents — agents that query and update your database and invoke your endpoints, behind your own role-based access control
- AI chatbots and expert systems — crawl a website, get an embeddable chatbot grounded in your own content
- Secure APIs over legacy databases — point it at an existing MySQL, PostgreSQL, SQL Server or MariaDB schema and get a CRUD API in seconds
- Wrappers around third-party APIs — paste an OpenAPI or Swagger URL and get typed, documented endpoints wrapping Stripe, GitHub, Slack or anything else publishing a spec
- MCP tool servers — expose your endpoints to Claude, Cursor, Codex, Qoder or any MCP client
- Background jobs and automation — scheduled tasks written in Hyperlambda, or generated from a plain English description
- Static sites and SPAs — your cloudlet serves files directly, next to the APIs powering them
How it compares
The LLM that cannot hallucinate functions
Magic runs Hyperlambda, which can be generated by our own proprietary LLM. Because we generate an AST rather than text, the output is analysed and rejected if it contains functions that don't exist. The Hyperlambda Generator cannot return hallucinated function invocations — like any LLM it can still write logically wrong code, but every function it invokes is guaranteed to exist.
Combined with the ability to restrict the vocabulary, this lets you ship AI agents that grow their own tool space on demand, without widening your attack surface.
Unique security model
Hyperlambda runs sandboxed, with no file system access outside its sandbox, and can whitelist individual functions through its RBAC system — so your server can accept code as input and execute it safely without knowing where it came from. Restricting invocations at the execution level makes Hyperlambda, as far as we know, the only language that currently does this.
I'm so confident in the codebase quality, I'll give you $100 if you can find a severe security-related bug in its backend code — and another $100 if you can exploit the natural language API, which has accepted arbitrary public input for 3 months with nobody succeeding.
MCP support — and an 80% token saving
Install the mcp plugin, point Claude Code, Cowork, or OpenAI's Codex at your cloudlet, and every HTTP endpoint in your modules folder becomes a tool the agent can invoke. In our measurements this also cuts token consumption by roughly 80%. Calculate your own savings here.
Performance
On a Chinook read endpoint (10 rows per request, pooled SQLite connections, 128 concurrent connections, measured with wrk), Hyperlambda served 64,664 requests per second, 3.7× the throughput of FastAPI with 4 workers (17,686) and 14× that of FastAPI with 1 worker (4,564). The 99th percentile latency was 5.6 ms, against 77.4 ms and 83.9 ms for FastAPI. Hyperlambda used about 9 cores and FastAPI with 4 workers about 4.6, so this is a measurement of throughput on one machine, not of efficiency per core.
Our earlier measurements put Hyperlambda around 50× faster than LangChain, and 100–1,000× faster than graphical workflow tools such as n8n, Zapier and Make, because it runs a real compiled runtime instead of interpreting logic out of JSON, XML or YAML. Hyperlambda solutions are broadly on par with C# and Entity Framework on both performance and scalability.
The dashboard
The sidebar is the whole platform: Hyper IDE for editing, running and replaying any file on the server, Playground for executing Hyperlambda without saving it first, SQL Studio for querying and designing databases, Endpoint Generator for turning tables into secured CRUD endpoints, wrapping caller-supplied code in a role-scoped sandbox, and importing third-party APIs from their OpenAPI specifications, plus users and roles, scheduled tasks, machine learning, and the plugin store.
Your cloudlet is also an AI agent. With the MCP plugin installed, the URL at the top hands any MCP-capable agent your endpoints as tools. The Chatbot Wizard goes the other way: give it a website, and it crawls the site, turns what it finds into training data, and hands you an embeddable chatbot grounded in your own content.
Once you save the code, you can test it — no deployment or publish step required.
Notice the prompt bar below the editor, where "the Machine Creates the Code". Describe what you want in plain English and the built-in generator writes it straight into the file you're editing. The same bar follows you into the Playground and SQL Studio, generating Hyperlambda, SQL, HTML, or whatever fits the file you have open.
Web Designer
Design your frontend in the browser, on the real file. Web Designer opens any HTML page your cloudlet serves and lets you edit it the way you would edit a document — click an element to select it, double-click a run of text to rewrite it, drag a block in from the palette, drag it somewhere else to move it.
There is no project format and no build step. The page in the middle is the file on disk: scripts are disabled inside the canvas, so what the browser has parsed is exactly what will be saved back. That is also why selection can reach a bare #text node — every run of text is its own thing in the tree, not a property of the tag around it.
The palette carries 60+ blocks, and each one arrives wearing the classes that page already puts on that kind of element — drop a button into the navbar and it lands looking like the other nav items. Style changes go into the page's own stylesheet, inside a fenced block, so your hand-written CSS above and below it is returned to disk untouched.
Code view puts the same file in an editor — HTML, or any stylesheet the page links, picked from a dropdown — with the "the Machine Creates the Code" prompt bar underneath. Live view runs the page for real, scripts and all.
Chat Ops
Ctrl+. anywhere in the dashboard opens Chat Ops: a conversation with your cloudlet that slides in over whatever screen you are on, and stays there while you navigate. Ask it to generate an endpoint from Hyper IDE and the file lands in the tree behind you — the conversation is still open when you turn round to look at it.
It talks to the default model, the developer-tools model, and it does not merely answer. It executes AI functions on your behalf: crawl a site, query a database, generate a CRUD API, scrape a URL, run a Hyperlambda snippet. Each invocation appears as a pill — amber while it runs, green when it succeeds, red when it throws — and clicking one opens the exact file and JSON arguments the model sent, so you can see what it actually did rather than trust a summary.
The whole loop is enforced server-side. A function the model tries to invoke that is not declared on the type is rejected before it executes, every function file carries its own auth.ticket.verify, and the invocation runs under your JWT — so Chat Ops can never do anything you could not do yourself from the dashboard.
Answers stream in as Markdown with syntax-highlighted code (Hyperlambda included), Mermaid diagrams render inline, and you can attach up to five files — either uploaded to the cloudlet for a function to work on, or handed to the model to read. Copy any code block, or the whole response, with one click.
Chat Ops appears only when an OpenAI API key is configured, and the key dialog is where you pick which model default runs.
Import any API
Point the Import API tab at any OpenAPI or Swagger URL — OpenAPI 3.x or Swagger 2.0, JSON or YAML — and Magic generates Hyperlambda endpoints wrapping whichever operations you tick. Query parameters and form fields become named, typed arguments carrying the specification's own types, defaults, enums and descriptions, and required ones get validators, so a missing argument is refused before the upstream API is ever contacted.
Because Magic publishes an endpoint's file comment as its MCP tool description and each argument's comment as that argument's description, an imported API arrives at your agent as a set of self-describing tools. Slack's chat.postMessage becomes fifteen individually typed, individually described arguments — not one of them written by hand.
The upstream credential is never written into the generated files. It is read from your configuration at the moment the endpoint is invoked, so the files stay safe to commit, and you declare which of your roles are allowed to invoke the wrapper.
Sandbox API — run caller-supplied code, safely
The Sandbox API tab of the Endpoint Generator turns the security model above into a feature you ship. It generates a single HTTP endpoint that executes code its own callers send it — Hyperlambda, or plain English turned into Hyperlambda by the generator — inside a whitelist you define per role.
You build a policy from an everybody base vocabulary plus per-role rules that add functions on top. A caller runs with the union of what their roles grant, so one role can reach a database another role cannot, and a function you did not grant does not exist as far as their code is concerned. A referenced function that doesn't exist is refused before anything runs, and an argument you pin — data.connect:northwind — restricts access to exactly that resource. Rate limit and execution timeout are set per role too. Capability wizards write the function lines for you — Database, HTTP, Files, Email, Logging and more — and the generated endpoint is a self-describing MCP tool like every other.
Pins take wildcards. data.connect:test-* allows every database with that prefix and nothing else; http.post:"https://api.example.com/v3/*" allows one API and no other host. File and folder functions compare the path segment by segment, so a wildcard stays inside the segment it occurs in the way it does in a shell — /etc/* grants a folder's files but not its sub-folders, /etc/*.md grants one extension within it. A pattern we don't implement throws rather than silently matching something its author didn't intend. Functions that read files on your behalf go through the file functions, so attaching a file to an email or hashing one needs the file pin too, not just the function.
There's a live one you can attack: a guest-only endpoint that grants nothing but read access to the Chinook sample database. Try to make it write — walkthrough and token here.
Rewind — step through an execution after it ran
A stack trace tells you where your code died. It rarely tells you why, because the values are gone by the time you read it.
Click Execute on any Hyperlambda file, fill in your arguments, then click Debug instead of Invoke. Magic runs the file while recording every slot it invokes, and hands you the recording. Each step carries your entire program as it looked immediately afterwards — so stepping through the list is watching your own state evolve, rather than guessing at it.
Click a step and the code highlights the statement that was executing. Arrow keys step back and forward. When something throws, the statement that threw is marked in red and everything that happened before it survives — if a loop ran forty times and the forty-first line failed, you can see the state the loop had built up at the moment it broke.
Recording happens only when you ask for it and lives only in memory. Nothing is written to disk, nothing leaves the server, and code running normally is unaffected — there is nothing switched on to slow it down.
OIDC sign-in
The dashboard signs in over OpenID Connect against Google, GitHub, LinkedIn, Microsoft Entra ID, Okta, Auth0, Keycloak and Slack — configured from the Configuration screen with a client ID (and, where the provider requires it, a secret) per provider. Code-flow exchanges run server-side with PKCE, only provider-verified email addresses are trusted, and identities are provider-scoped so a sign-in can never collide with another account. A provider is a single Hyperlambda file — drop in a new one and the login screen picks it up automatically.
Getting started
Deploy to DigitalOcean (recommended)
One droplet running the full stack, with persistent volumes for your data, configuration and modules. Create your droplet — edit the single DOMAIN= line in .do/cloud-init.yaml and paste it into the User Data field. HTTPS is automatic through Caddy and Let's Encrypt. Full guide: DigitalOcean deployment guide
Kubernetes (own cluster)
The root docker.backend/docker.frontend images run unmodified in your own cluster. To make request.ip/request.scheme resolve the true end user behind your ingress (and Cloudflare, if in front), follow the client-IP deployment note.
Docker Compose (self-hosted)
The one-liner at the top of this README is the fastest route. If you'd rather keep the file around:
version: "3.8"
services:
backend:
image: servergardens/magic-backend:latest
platform: linux/amd64
container_name: magic_backend
restart: unless-stopped
ports:
- "4444:4444"
volumes:
- magic_files_etc:/magic/files/etc
- magic_files_data:/magic/files/data
- magic_files_config:/magic/files/config
- magic_files_modules:/magic/files/modules
frontend:
image: servergardens/magic-frontend:latest
container_name: magic_frontend
restart: unless-stopped
depends_on:
- backend
ports:
- "5555:80"
volumes:
magic_files_etc:
magic_files_data:
magic_files_config:
magic_files_modules:
Run docker compose up, visit localhost:5555, log in with root / root, and configure the system. More installation options here.
Run from source
You'll need .NET 10 and Node.js (latest LTS).
# Backend — starts the API on http://localhost:5000
cd backend
dotnet run
# Frontend (in a second terminal) — dashboard on http://localhost:4201
cd frontend
npm install
npm run dev
Open http://localhost:4201 and log in using http://localhost:5000 as your backend URL, with root / root.
Bring your own OpenAI API key
Magic uses OpenAI by default — create a key here. If you'd rather not use OpenAI, there are Ollama and HuggingFace plugins that override the inference functions, and chatbots can use BM25 keyword retrieval instead of embeddings — full-text search over your training data, running entirely inside SQLite, needing no OpenAI key and no vectorisation. Semantic and hybrid retrieval still use OpenAI's embeddings API. And if you drive Magic through the MCP server, you don't need an OpenAI key at all.
AI agents
Below is Magic's AI agent autonomously browsing the web and filling out a "contact us" form, using the integrated headless browser that lets your agent see the web and solve tasks on it.
You can vibe code AI agents integrated with your CRM, ERP, or legacy databases. Magic fundamentally is an AI agent for building software and AI agents — what you use it for is up to you.
Headless browser
Magic embeds PuppeteerSharp, so agents can browse like a human — filling forms, clicking buttons. An example prompt: "Go to xyz website, identify their contact us form and change URLs if required, and fill out their contact us form." The screenshot above is the result of exactly that prompt.
Python, terminal, and C# integration
Generate and execute Python on the fly and let the LLM use it as a tool, use Bash and the underlying terminal, and create Hyperlambda keywords in C#. Persisted Python scripts can be referenced later as tools, permanently widening your agents' capabilities.
Notice — you must be logged in as root to generate and execute Python or terminal scripts, or create C# extensions. Magic's security model eliminates entire classes of holes, but it is not a magic pill; don't expose endpoints that let third parties execute arbitrary code.
AI chatbots and expert systems
Deliver your agents as password-protected AI expert systems, or as embeddable chatbots on any website. Try ours here.
Chatbots are grounded in your own content through RAG, with three retrieval modes per model: semantic (cosine similarity over OpenAI embeddings), keyword (BM25 full-text search — built on SQLite's FTS5, no OpenAI key and no vectorise step needed), or hybrid, fusing both rankings so paraphrased questions and exact terms such as product names each find the right training snippet. The crawler splits pages into subject-scoped snippets titled as the questions users actually ask, which is what makes retrieval precise in the first place.
Also a web server
Magic serves your frontend itself, so there's no compilation, build process or pipeline between writing code and testing it:
- Create your prompt
- Press enter
- Test
This is in stark contrast to tools such as Lovable and Bolt, which require deploying into two different third-party providers before you can even test. It also ships pre-built frontends, such as the AI Expert System for serving password-protected agents or entire SaaS AI solutions.
... and, arguably, a CMS
Install the Hyper CMS plugin (hyper-cms) from the plugin store and your cloudlet becomes a website platform as well: a templated starter kit with blogging built in, served straight from your cloudlet, with pages that can pull content from the backend through server-side rendering. Magic is no longer only the thing behind your site, it is also the site.
It also combines with the rest of the platform:
- Web Designer edits the CMS pages visually, on the real files, with no build step.
- Chat Ops lets you ask your cloudlet to add a page, write a blog post or change the layout, instead of clicking through an admin panel.
- MCP connector lets Claude Code, Cowork or Codex build and maintain the website for you, creating pages and publishing articles with the same tools they use for your endpoints.
Edit by hand, by dragging blocks, by chatting, or by delegating to an agent, and it is all the same files on disk.
Git integration
Magic was built for software developers from day one, so Git is integrated as part of the platform. Create a project, vibe code your tools and even your GitHub workflows, then commit and push.
DIY home cloud
Magic installs happily on something like a Mac Mini using the Docker images. Combined with a CloudFlare tunnel you can serve applications and data out of your home in minutes. The screenshot below is from such a system, running out of a home Mac Mini in a house in Larnaca, Cyprus, through such a tunnel — tested from the US, Norway and elsewhere, and surprisingly responsive for the connection it's served over.
A setup like this keeps your applications and your data entirely under your own control, on hardware you own.
The LLM
Internally the system defaults to OpenAI's gpt-5.6-luna, but everything is tunable, and with some effort you can swap the defaults for Ollama or HuggingFace models. The Hyperlambda Generator's training dataset is not public and won't be. Worst case, you keep running everything you've already generated; you'd only lose the ability to generate new code.
The screenshot above is a publicly available page accepting input from any visitor. That input is transformed into Hyperlambda by our LLM and executed in-process behind our DMZ — with a standing $100 bounty for anyone who can exploit it to reach PII. Nobody has.
Technology
Magic Cloud is built in .NET 10, with a React, Vite and TypeScript dashboard. Hyperlambda is built on a design pattern called Active Events ("slots and signals"), an in-process model for executing dynamic functions that eliminates cross-project dependencies and yields extreme encapsulation. That pattern is what makes the security model possible: AI-generated code can be trusted because it simply lacks permission to do anything harmful unless you granted it.
FAQ
Is it really free? Yes — MIT licensed, self-hostable, no feature gates. The hosted Hyperlambda code generator is currently free to use; future pricing is expected at $49 per 1,000 requests, and there is no payment wall today.
Do I need an OpenAI API key? For AI code generation and semantic (embeddings) retrieval, yes. If you drive Magic over MCP from Claude or Codex, no. Ollama and HuggingFace plugins can replace inference, and chatbots configured for BM25 keyword retrieval search your training data with SQLite full-text search — no OpenAI involved.
Can I run it completely on my own hardware? Yes. Everything — database, API, frontend, scheduler, chatbots — runs in your own containers, on your own machine.
How is this different from Lovable or Bolt? They generate a frontend and hand the backend to a third-party service. Magic generates and runs the whole backend, needs no deployment step before you can test, and is yours to self-host under MIT.
What database does it use? SQLite out of the box, with full support for MySQL, PostgreSQL, MariaDB and SQL Server. No connectors required.
Do I have to learn Hyperlambda? No. The generator writes it from plain English, and the dashboard's prompt bars cover most workflows. Reading Hyperlambda is much easier than writing it.
What happens if AINIRO disappears? Everything you've generated keeps running — it's MIT-licensed code on your hardware. You'd only lose the ability to generate new code with the hosted generator.
Is AI-generated code safe to execute? That's the point of the security model: Hyperlambda is sandboxed and its vocabulary can be whitelisted per role, so generated code can only invoke functions you explicitly allowed.
Contributing
Contributions are welcome — bug reports, feature requests, documentation, and code.
Repository structure
Building and testing
# Run the backend — builds and starts the API on http://localhost:5000
cd backend
dotnet run
# Run a plugin's unit tests (each plugin's tests live in its *.tests project)
cd plugins/<plugin>/<plugin>.tests
dotnet test
# Type-check and build the dashboard
cd frontend && npm install && npm run build
Submitting changes
- Fork the repo and create a feature branch.
- Make your change, and make sure
dotnet testand the frontend build both pass. - Open a pull request with a clear description of what changed and why.
Found a security issue? Please read SECURITY.md and report it privately rather than opening a public issue.
Maintenance
Magic Cloud and Hyperlambda are developed and professionally maintained by AINIRO.IO, copyright Thomas Hansen 2019 – 2026. We offer hosting, support, and software development services on top of Magic Cloud, in addition to delivering AI agents, chatbots, and AI solutions.
License
MIT, as published by the Open Source Initiative — see LICENSE. For licensing inquiries contact Thomas Hansen, [email protected].