The same tools and workflows your users see, driven end to end: prepared, inspected, finished.
AGENT-NATIVE LANGUAGE AND RUNTIME
Turn your software into an agent-native environment.
An agent-native application is one an agent can inhabit — discover it, work it, and extend it from the inside. The engineer who spends a week preparing a model, the technician who builds every case by hand: with Luna, that expertise lives inside your product — because the application itself is the agent.
WHAT LUNA IS
Any application can embed a scripting language. Scripts run when called, errors surface at run time, and whatever they touch is simply changed. Luna is built for something else: an expert working inside the application — and extending it when the work needs more. Its first act is asking: the application describes itself, and a fresh agent can be dropped in and learn it in minutes.
A compiler lives in the product. Everything an agent writes is fully checked before it can run — types, calls, effects, even termination — and a mistake refuses with a readable sentence instead of failing in front of a user. Nothing unchecked ever executes.
The runtime is the sandbox. The agent does not run loose in your process — it lives inside Luna's runtime, and everything it does happens there. Experiments clean up after themselves; live motion leaves no trace; what someone deliberately keeps lands as one numbered act in a record the whole team — human and agent — shares, can read, walk backward, and replay.
Types, calls, effects and termination are proven before execution.
02 / EXPERIMENTS ARE CONTAINEDA tool's working state is put back when it endsA tool's temporary changes are undone when it closes.
03 / ONE ACCOUNTABLE RECORDEvery kept change is a numbered actPeople and agents share one record you can walk back and replay.
THE PACKAGED EXPERT
Expert work lives inside applications: days of preparation, judgment, and repetition by the people who know the tool best. That expert can now ship with the product — and it is not bound by the UI. It works at program speed — trying things in its own workspace, with every attempt checked, contained, and recorded.
The same tools and workflows your users see, driven end to end: prepared, inspected, finished.
A workflow, a tool, a checked function — written like an expert engineer would, published into the running product for end users.
The application becomes the interaction surface between your end users and their expert. They cooperate in the product, not beside it.
An agent given buttons stalls where no button fits, and hands the job back.
The resident writes the missing step and finishes — and the step stays.
It reads the signatures, documentation, and authored source of the application it lives in.
It drives the same tools and workflows people use, in its own workspace.
When a step is missing, it writes it — and the resident compiler checks everything before it runs.
Finished work lands as numbered acts in the one record people and agents share.
Useful in this session, immediately. What the agent builds is usable immediately — by it, by the application, and by people. Putting it in front of end users is a separate, deliberate step.
A developer can later choose to ship a proven program to every customer. The first user does not have to wait for that release.
The agent can try things freely. While a tool is open, its changes are temporary — close it, and everything it touched goes back to how it was. Moving, adjusting, experimenting: none of it leaves a trace by itself.
Keeping a result is a deliberate step. When someone — a person or the agent — decides their work is done, it is saved as one clean entry in a shared history. Anyone can see what changed, and step back to any earlier point.
See how the runtime holds live work and recorded changestemporary changes — no history
save #41 lands
THE APPLICATION IS THE WORKSPACE
Both paths use the same language and runtime. You choose exactly which of your application's capabilities the language can reach; your implementation stays private. The agent develops new programs, and your application can call them.
Keep your interface and native implementation. Expose the capabilities an agent can build with, then call the functions it publishes.
The compiler and runtime can run headlessly. Your application supplies the interface.
Author tools, panels, interactions, and workflows in the same language the agent uses to extend them.
A new capability can become part of the running interface through the same authored functions.
Checked programs · live environment · record
Luna programs beat standard Lua in all six measured workloads, and calling into your application's native code is nearly free. See the work, comparison languages, and measurement notes together.
Explore the benchmarksWarm processor cycles per element, one of the six measured workloads. Method and all rows are on the language page.
GO ONE LEVEL DEEPER
LUNA
Embed Luna in the application you run today, or build an application whose tools and workflows are Luna programs. Give people and agents a shared place to make it better.
A mesh engineering agent that can run in its own application or be embedded in software that works with geometry.