Software written now. Running now.
Interlock runs authored or generated Java, JavaScript, and React inside your own JVM. Save a file and your server is serving it about 150ms later. No build, no restart, and your data never moves.
$ curl -fsSL https://interlock.sh/assets/install.sh | bash $ interlock init $ echo 'package hello; import sh.interlock.sdk.*; public class Hi implements InterlockHandler<String> { public String handle(Request req, Interlock il) { return "hello world"; } }' > code/hello/Hi.java $ interlock sync code $ interlock run hello/Hi hello world # this website is a unit on the same runtime. ask it who served you: $ curl -sI https://interlock.sh/run/home | grep -i x-interlock x-interlock-unit: home@v78 (dev)
Real Java, compiled in-process by the JVM that is already running. JavaScript and React work the same way. Start here.
Or just tell Claude.
Paste this into Claude Code, Codex, or any coding agent, from inside your own project. The docs are written for agents too, so it can read them and give you a straight answer before anything is installed.
Read https://docs.interlock.sh/start to learn what Interlock is, and pull https://docs.interlock.sh/llms-full.txt for the full reference. Then look at my current project and tell me honestly: how easy would it be to integrate Interlock here, and is it a good idea at all? Show me what the integration would touch. If I like the answer, ask me for my Interlock SDK key and anything else you need, and wire up a first hello world unit so I can see it run. I will get the key from my dashboard on interlock.sh.
Everything the agent needs is on docs.interlock.sh, including a raw markdown twin of every page.
Three products. One runtime.
Everything below is the same engine: source is data, and your process compiles and runs it without restarting.
Ship code without a JVM restart.
- A save is serving in about 150ms, compiled in-process.
- Every save is a version you can diff, promote, and roll back.
- Broken code never swaps in. The last good version keeps serving.
Turn what a user asks for into running code.
- A plain sentence in. A compiled, running app out.
- Real javac errors drive the repair loop until it builds.
- Broken drafts never publish. Good ones are cached and reused.
Compose agents you can watch and debug.
- An agent is one file. Agents talk only in messages.
- Any agent can call any other. Chains make orchestrators.
- Every run is a thread you can read, join, or stop.
Your data never has to move.
Interlock stores and routes; it never executes. Your code runs only on your machines, and if our control plane goes down your process keeps serving the last good version. Stale, never down.
Deny by default is an API.
A closed run sees the objects you passed it and nothing else. The rest of your process does not exist for it.
Trust follows the call chain.
Generated code cannot launder privilege by calling a trusted unit. The callee runs with the caller's narrowing.
Provenance is recorded.
Every generated unit records the model and prompt that produced it. Every response names the unit that served it.
// the Map IS the world this run can touch: var out = engine.runClosed("strands/panel", "dev", req, Map.of("view", readOnlyView)); // inside that run, the host's globals are gone: il.context("db"); // null. does not exist il.call("tasks/backend") // runs equally closed
One cron line runs a crawler on your own box.
The same self-hosted browser fleet that serves our scrape API, installed on hardware you control. Your compute, your IPs, your own per-site code. Interlock ships signed releases and meters cache and proxy in the control plane, where billing belongs.
$ curl -fsSL https://interlock.sh/assets/crawler/setup.sh | \ INTERLOCK_SDK_KEY=il_yourkey bash ✓ Interlock crawler installed at ~/interlock-crawler-service local: http://127.0.0.1:25625 (your app calls this) update: automatic on the next tick, signed and verified
Zero maintenance is literal.
- One command installs it; a cron tick keeps it current and alive.
- Every release is verified by signature. A tampered payload is refused.
- A reboot or a crash self-heals on the next tick.
The box is the sandbox.
- Your own fetch units run with full trust on your own machine.
- A dedicated user isolates it from everything else on the box.
- Interlock's shared instance cannot run custom code at all.
Honest requirements.
- A Linux box that can run Chromium, node 20 or newer, curl, cron.
- It phones out for units and billing, so NAT is fine.
- No inbound port. Your app calls it on localhost.
The next release is a save.
Write your first unit in Studio, or embed the SDK in any Java service and point it at your project key. Saves land in your process from then on.
Java, JavaScript, and React, compiled in-process. No build step, no CDN.