Magic Cloud

Describe what you want in English and get a working application: database, secured API and frontend, on your own server, in minutes and for cents. Magic Cloud is the open-source platform. Hyperlambda is the language it runs.

# When it's up: log in at http://localhost:5555 with root/root
# Change that password before the internet does.
$ curl -fsSL https://hyperlambda.dev/docker-compose.yaml | docker compose -f - up

Put AI agents on the SQL you already run

Wrap SQL Server, MySQL, PostgreSQL or SQLite in role-gated APIs and MCP tools. No migration, your data stays where it is.

Database, API and frontend from a conversation

CRM, ERP, logistics, back-office tools: a complete application on hardware you own, with users, roles and sign-in built in.

Agents that build their own tools

Every endpoint is an MCP tool, and an agent can ask for a tool that does not exist yet, inside a runtime it cannot escape.

From one prompt to a working application

“Create a CO2 calculator that allows people to measure their CO2 impact”

That prompt produced a complete application on a Magic cloudlet — SQLite database, public and role-gated API endpoints, and the frontend itself, all served from the same system. An AI agent built the whole thing autonomously in five minutes during a live client meeting: database, endpoints, SPA — deployed and smoke-tested before the call ended.

• One system, one deployment — database, secured API, and frontend together.
• Five minutes, start to finish — generated by an agent from that one sentence.
• Custom branding and design — a real product, not a template.

Click the screenshot to open it full size.

Describe the app. Chat Ops builds the whole stack.

“Create me a full stack app, with a database, and API, and a frontend!”

Chat Ops is the agent inside every Magic dashboard. Give it a sentence like that and it reads the platform guides, asks the product decisions it needs — what the app does, where the data lives, which entities, what kind of login, what the frontend should look like — and then builds the database, the role-gated API and the frontend on the same cloudlet, with nothing to deploy afterwards.

• CRM and ERP systems — customers, orders, stock, invoices, with roles per department.
• Logistics and inventory — shipments, warehouses, ledgered stock, booking systems and project trackers.
• Line-of-business apps and back-office dashboards — the internal tools every company runs on, over a new database or the one you already have.

Click the screenshot to open it full size. A complete CRM in one conversation is the measured version.

A CRM, from nothing to signed-in users in two minutes

This is Orbit, a CRM built on a Magic cloudlet in two minutes of conversation. Companies, contacts and activities, an overview with live counts and pipeline status, and a signed-in user — database, role-gated API and frontend, all served from the same cloudlet the moment the conversation ended.

• Real data model — companies, contacts and activities as tables, with the API generated per table and per verb.
• Real login — users and roles from the platform, so a prospect list is not a public page.
• Real design — a branded, custom frontend rather than a template, delivered as part of the same two minutes.

Click the screenshot to open it full size. The full time and cost ledger for a CRM like this is on the blog.

From English to safe execution

You describe the task, the generator compiles it to Hyperlambda, and the runtime executes it inside a whitelist: a list of the exact operations generated code may perform. Anything not on the list fails before it runs, so the runtime, not the model, is the security boundary.

Describe the task

Write what you want in natural language

Compile to Hyperlambda

The compiler turns your request into Hyperlambda AST

Execute safely

Magic Cloud runs the result inside a constrained C# runtime

“Create an endpoint that returns unpaid invoices for a customer.”

.arguments
   customer_id:long
data.connect:billing
   data.read
      table:invoices
      where
         and
            customer_id.eq:x:@.arguments/*/customer_id
            status.eq:unpaid
   return-nodes:x:@data.read/*

[
  {
    "id": 42,
    "customer_id": 7,
    "invoice_number": "INV-10042",
    "amount": 1299.00,
    "due_date": "2026-05-15",
    "status": "unpaid"
  },
  {
    "id": 57,
    "customer_id": 7,
    "invoice_number": "INV-10057",
    "amount": 249.50,
    "due_date": "2026-06-01",
    "status": "unpaid"
  }
]

• The model proposed the structure above; it never wrote free-form source code.

• Magic Cloud validated every node against the whitelist before execution.

• A hallucinated or unauthorised operation fails before it runs, instead of running badly.

• The same check runs for a human, an agent, or an agent extending itself.

• Hallucination-resistant. Free-form generated code can do anything its language can; a constrained structure can only do what it is allowed to.

• Sandboxed by construction. The boundary is a property of the runtime, not a prompt, a linter or a review step.

• Agents that build their own tools. Because generated code cannot escape, an agent can safely generate new tools, workflows and APIs on demand.

Everything your cloudlet can do, in one place

Every Magic Cloud install ships with a dashboard for building and running your backend.

• Hyper IDE — edit and execute any file, with Hyperlambda autocomplete.
• SQL Studio & Generator — design SQLite, MySQL, PostgreSQL and SQL Server, and turn tables into secured CRUD APIs that AI agents can call.
• MCP & Machine Learning — expose endpoints to any MCP harness, and train embeddable chatbots on your own content.

Click the animation to open it full size.

Honest comparisons

Feature matrices written the uncomfortable way — including the rows we lose.

[

Self-hosted first, MIT everything, agent-native — and when you should still pick them.

](https://hyperlambda.dev/supabase-alternative)[

They enumerate 1,000+ integrations. Magic generates them on demand.

](https://hyperlambda.dev/n8n-alternative)[

Same MIT single-box DNA, opposite bet on who extends the backend.

](https://hyperlambda.dev/blog/magic-vs-pocketbase-an-honest-feature-matrix)

From prompt to Full Stack in 7 minutes

In this video I demonstrate how to create and deploy into production a full stack app in 7 minutes, 100% on requirements, and exactly what the client wanted.

Everything in the video ships with every install — MIT-licensed, self-hosted, and running on your own machine minutes after the Docker command at the top of this page.

Developers on Magic and Hyperlambda

Samuele Contardi Software Architect

Alex Erdei Frontend Developer

Justin Lietz Software Engineer

What is Hyperlambda?

Hyperlambda is a programming language whose code is a tree structure rather than free-form text — effectively an executable AST. That structure is what lets natural-language requests compile into something deterministic and inspectable before it runs, which is why it suits AI-generated backends.

What can I actually build with it?

Complete full-stack applications — secured CRUD APIs over your databases, frontends and SPAs served from the same cloudlet, backend workflows, scheduled tasks, AI agents and tools, and embeddable chatbots trained on your own content. All generated from short natural-language prompts rather than hand-written.

Can it build complete applications, including the frontend?

Yes. A Magic cloudlet serves static sites and single-page applications alongside the APIs they consume, so a working prompt-to-app flow is: design the database, generate the secured endpoints, and deploy the frontend — one system, one deployment. Users, roles, and full OIDC and OAuth support are built into the platform, so the applications you ship come with real authentication rather than something bolted on per project.

Do I need to know Hyperlambda to use it?

No. You describe what you want in plain language and the generator compiles it to Hyperlambda for you. Knowing the language helps you read and adjust the result, but it is not required to build working backends.

What makes AI-generated code safe to run?

Generated Hyperlambda compiles to a structure whose every node must bind to an explicitly whitelisted capability in the current context; anything outside that fails before it executes. The model proposes, the runtime decides.

Does it work with any LLM or AI coding agent?

Yes. The runtime's safety model is independent of which model generated the code. Magic integrates OpenAI, Ollama and HuggingFace for its own AI features, and with the MCP plugin installed your cloudlet exposes an MCP server that any MCP-capable harness — including Claude, Codex, Cursor and Qoder — can connect to, using your endpoints as tools.

What does Magic's MCP server do?

It turns every endpoint on your cloudlet into an MCP tool, with no tool definitions to write and no separate server to host. The cloudlet runs its own OAuth 2.1 flow, so Claude, Claude Code, Cursor or any MCP client connects by pasting one URL and authorising. The tool list is filtered by the roles of the user who signed in, and the same role check runs again on every invocation. Endpoints generated from a database table, imported from an OpenAPI specification, or described in a sentence all appear as tools — and an agent can ask for a tool that does not exist yet and have it generated in seconds. The full page is MCP Server.

What databases does it support?

SQLite is built in, and you can connect external MySQL, PostgreSQL and Microsoft SQL Server. Once connected, the platform treats an external database like a local one for querying, design and code generation, and its tables become MCP tools for connecting AI agents to your existing SQL database.

Which sign-in (SSO) providers does it support?

Magic ships single sign-on out of the box for Google, GitHub, LinkedIn, Microsoft Entra ID, Okta, Auth0, Keycloak and Slack. Each provider is turned on from the dashboard with a client ID, external identities are scoped per provider and mapped onto Magic's own role-based access control, and a provider is a single Hyperlambda file — so adding another is dropping a file into a folder.

Do I have to use a cloud, or can I self-host it?

You can self-host it entirely. Magic Cloud runs on your own server — a single Docker command brings up the full stack — and nothing leaves your machine unless an integration you configure sends it somewhere.

Thomas Hansen — creator of Hyperlambda

I wrote my first line of code at eight years old, and 44 years later I am still at it. Hyperlambda is the part I care most about — a language I created because I believe the answer to unsafe AI code generation is not better prompts, but a runtime that cannot be talked into doing the wrong thing.

Magic Cloud has been running in production for years, and every line of it is MIT-licensed and public. That is the deal: you can read everything, run everything on your own hardware, and the code stays yours no matter what happens to me. The bounty below is not marketing — I offer it because I know how the sandbox is built.

One Docker command. Five minutes. Your hardware.

# When it's up: log in at http://localhost:5555 with root/root
$ curl -fsSL https://hyperlambda.dev/docker-compose.yaml | docker compose -f - up

Prefer it hosted? AINIRO runs cloudlets — same code, nothing gated.

I dare you to break the sandbox

Escape the Hyperlambda execution sandbox from the playground — make generated code do something the whitelist forbids — and I will pay you $100. Nobody has.