The runtime is the security boundary — not the model

Secure AI Code Execution, Enforced by the Runtime

Every AI coding stack faces the same question: what happens when the model generates something it shouldn’t? Prompt filtering hopes it won’t. Code review hopes you’ll catch it. Magic Cloud answers it structurally: generated Hyperlambda is an AST whose every node must bind to a whitelisted capability — anything outside the whitelist fails before execution. The model proposes. The runtime decides.

Whitelisted slot execution — capabilities constrained per context, per function
A hallucinated capability fails structurally, before anything runs
$100 standing bounty on escaping the sandbox — unclaimed
The argument

Why prompt filtering is not a security model

Most stacks secure AI-generated code the way you would secure a junior developer you cannot fire: instructions, review, and hope. The generated artifact is free-form source code, the security assumptions live inside it, and every generation is a fresh opportunity to get them wrong. Probabilistic authors are sometimes wrong — that is not a flaw to be prompted away, it is the nature of the tool.

Magic inverts the boundary. Hyperlambda is not text that gets executed — it compiles to an abstract syntax tree, and every node must bind to a slot the runtime explicitly exposes in the current execution context. Whitelisting constrains which slots are available down to the individual function; endpoints declare which roles may invoke them. If a capability is not whitelisted, code cannot bind to it — not “is instructed not to,” cannot. The worst a bad generation can do is fail, structurally, before execution.

This is what makes agents holding production credentials defensible: security is a property of the runtime, implemented once, deterministically — not a property each generated application must reimplement. The deep dive is runtime whitelisting, not prompt filtering; the adversarial test is the standing $100 bounty. Nobody has claimed it.

Frequently asked questions
What makes AI-generated code safe to run on Magic?

The security boundary is the runtime, not the model. Generated Hyperlambda compiles to an AST whose nodes can only bind to explicitly whitelisted capabilities in the current context; anything outside that fails before it executes.

Does this depend on which LLM generates the code?

No. The runtime’s safety model is independent of the generating model — Claude, a local model, or the built-in Hyperlambda Generator. The whitelist constrains what any of them can produce into execution.

How is this different from sandboxing generated Python or JavaScript?

Traditional sandboxes contain arbitrary code after the fact — and containment escapes are a research field. Hyperlambda is constrained before the fact: the language itself cannot express an invocation of a capability the context does not expose, so there is nothing to contain.

Has anyone broken the sandbox?

No. There is a standing $100 bounty on escaping the Hyperlambda execution sandbox from the public playground — making generated code do something the whitelist forbids — and it remains unclaimed.

Try it

Five minutes to a running cloudlet

The whole platform — database, generated APIs, auth, frontend hosting, and the MCP server — on your own hardware, MIT-licensed.

terminal
# 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