Inference runs sandboxed on your machine
The coding model — open-weight, from whichever registry you pick — runs locally, isolated in a sandbox, with no network call at inference. Your source is read on disk and never transmitted.
One engine, many people
What people build with OpenEng.
The same private, on-device engine — driven from your browser, composed from 3,300+ building blocks — solves very different problems. Here are three of them, from the code that can never leave a laptop to a governed fleet to a fully offline power user.
Code stays local Governed at fleet scale Works offline
Persona · 01
The code never leaves the laptop.
For engineers under NDA, regulated data rules, or hard IP constraints, the cheapest mistake is the one where a proprietary file lands in someone else's logs. OpenEng makes that physically impossible — the agent and its models run isolated in a sandbox on your machine, and the browser it's driven from never receives a secret to leak.
The problem
You want an agent that reads your real codebase, runs your real tests, and ships real diffs — but every cloud assistant means shipping your source to a third party. Legal says no. Security says no. So you do it by hand.
The OpenEng workflow
- 1
Sign in
One-click browser sign-in to auth.openeng.ai. Sign-in is identity only — no data plane to opt out of.
- 2
Compose a config
Pick an on-device coding model and an always-on guardrail in the Console; publish a versioned id@version.
- 3
Run on your engine
Run openeng serve. The console connects through OpenEng's broker and every token is inferred on your own CPU/GPU.
Your engine, your machine
openeng serveThe egress invariant
The channel carries only your request and the rendered tokens — no field for prompts, persona, memory, embeddings, secrets, or keys. There is nothing for a leak to travel through.
A thin client by construction
The browser bundle holds no model and no secret. It cannot leak what it was never built to hold — and the channel to your engine is encrypted end-to-end, even on your own machine.
The proof
Encrypted end-to-end
The channel to your engine is encrypted end-to-end — even on your own machine.
No telemetry, ever
No analytics, no crash pings, no usage beacon. The broker only relays ciphertext it can't read.
Secrets stay in env
Configs store ${ENV} references only — actual secrets resolve from your local environment.
Kernel-sandboxed runs
A real OS-level kernel sandbox: read-only root, network off, destructive actions deny by default.
Private by construction
Privacy is a property of the architecture — the models run on your machine and the wire has no field to leak.
Open-weight models
28 open-weight on-device models — any registry, any format, the runtime that fits; point a role at a hosted model through the gateway if you prefer.
Persona · 02
One versioned config governs the whole fleet.
A platform team doesn't want fifty engineers each wiring their own agent to production cloud. They want one approved setup — cloud-aware agents bound to the company's own AWS, Azure, and GCP through cells, frozen into a version every machine resolves by name, and run unattended on a schedule.
app.openeng.ai
Migrate the users table to Postgres and update the data layer.
Planning · 4 steps
- Map the current schema
- Write the migration
- Update the data-access layer
- Update tests + docs
Ask anything…complexity 84% · planned
The problem
Every engineer pointing their own ad-hoc assistant at prod is config drift, credential sprawl, and an audit you can't pass. You need a single governed definition — not a wiki page everyone ignores.
The OpenEng workflow
- 1
Sign in
One OpenEng account, with API keys for the headless runners that have no human at the keyboard.
- 2
Compose a config
Wire agents to your cloud via cells, set guardrails and approval gates, publish an immutable id@version.
- 3
Run on your engine
Every machine that signs in pulls the exact same setup; schedulers run it headless on cron.
Cloud-aware via cells
550 cells connect agents to AWS / Azure / GCP — read-only by default, and always inside your own IAM. The engine never holds standing cloud credentials of its own.
- Your IAM, your boundary
- Read-only unless you grant write
Immutable, versioned
Publish-once with strictly-higher SemVer. See exactly what the fleet will run before you ship it — the Console is a mirror of the config, not its source.
Headless schedulers
Cron-validated jobs and always-on headless runners execute the same versioned config unattended, with human-in-the-loop approval gates where you want a checkpoint.
The proof
16 config domains
Models, agents, execution flow, schedulers, templates, cells, plugins, guardrails, MCP servers — one console.
No drift
Resolve a config by id@version and every machine runs byte-identical — nothing local to forget to update.
Approval gates
Human-in-the-loop checkpoints pause a run for sign-off before a sensitive action proceeds.
1,092 agents
A 3-level org chart — 282 orchestrators delegating to 810 single-purpose agents — to compose from.
Capped sandboxes
Cloud-coordinated sandboxes with a resource governor (default 10% CPU/mem) keep fleet runs bounded.
Size it yourself
Enterprise pricing scales by configs, schedulers, headless runners, sandboxes, and seats — no quote call.
Persona · 03
28 models, zero API keys, fully offline.
Some people just want a capable agent that runs on their own hardware — no subscription to a model lab, no key to rotate, no network required on a plane or behind an air gap. OpenEng ships a whole team of open-weight models that fit your machine and pay-as-you-go credit only if you ever want the cloud.
The problem
Cloud assistants meter every keystroke, expire your trial, and stop working the moment your Wi-Fi does. You want capability you own outright — and a bill of exactly zero when you aren't calling anyone's API.
The OpenEng workflow
- 1
Sign in
Identity once. The Free tier gives you the full on-device engine and the browser console.
- 2
Compose a config
The installer auto-matches models to your hardware; pick a persona and publish — no keys to paste.
- 3
Run on your engine
Work fully offline on embedded models; top up pay-as-you-go credit only if you reach for the cloud.
Install the engine
curl -fsSL https://openeng.ai/engine/install.sh | bash28 open-weight models
From a 1.3 GB model to a 70B, auto-matched to your hardware — pulled from any registry, in any format, on the runtime that fits. Map several to a role group so each job runs on a right-sized model.
- Runs on a laptop or a workstation
- Optional Metal / CUDA / Vulkan
Works fully offline
No network at inference. On a plane, behind an air gap, or on a flaky connection, your agent keeps writing code and running goals.
Pay only if you go cloud
Embedded inference costs nothing. If you ever want a cloud model, top up token credit from $5 — metered in micro-USD with reserve-then-settle, so you're never charged for a turn that doesn't run.
The proof
Zero API keys
The whole embedded suite runs key-free out of the box — nothing to sign up for, nothing to leak.
$0 to run
The full on-device engine and browser console are Free, forever, with no telemetry.
Hardware-aware
The installer selects the right model set for your CPU/GPU and RAM automatically.
Self-routing
An embedded model scores each request 0–100 and routes plan-vs-execute — you never pick a mode.
Credit never expires
PAYG top-ups (up to $5,000,000) are spent whenever you like; card details are never stored.
Threads everywhere
Engine-owned threads are shared across the Web Console, CLI, and Desktop — same account, same history.
The common thread
Three people. One workflow.
However different the goal, the shape never changes: sign in for identity, compose a config in the browser, and run it on your own engine. The intelligence and the secrets stay on your machine — every time.
The engine is local
A Rust engine that runs only on your machine — binding no inbound port — owns the agent loop, the models, the memory, and every cloud call. The browser only renders.
The config is portable
Author once, freeze an id@version, and run it identically on any machine you sign in to. The same building blocks compose all three personas.
The boundary is yours
Cells stay inside your IAM, secrets resolve from your environment, and the wire schema simply has no field to carry your data off-box.
Privacy-bound builder
Code never leaves the laptop.
Platform standardizer
One config governs the fleet.
Local-first power user
28 models, offline, key-free.
Find your workflow in one command.
Sign in, run openeng serve, and your browser console connects. Whatever you're building, it stays on your machine.
Install the engine
curl -fsSL https://openeng.ai/engine/install.sh | bash