The same private, on-device engine — driven from your browser, composed from 5,100+ building blocks — solves very different problems. Here are three of them, from code under NDA whose files stay on a laptop to a governed fleet to a local-first power user.
Status: OpenEng AI isn’t live yet. The Console and Web Console interfaces load, but the OpenEng AI API routes and the Broker aren’t deployed. Nothing can be saved or published, and no AI engine can register or connect. Pro, Enterprise, and pay-as-you-go launch in Q4 2026 and can’t be purchased yet. These workflows describe how it is built to work.
Persona · 01
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 processes your files where they live: the agent and its local models run on your machine, and the engine reads your files there. What travels, encrypted, through the OpenEng Broker is what you exchange in the Web Console — what you type, which the Broker can open to route it; the engine's streamed replies, which it cannot read; and the thread history and memory the console shows you, which it opens to deliver — and it keeps all of it for 7 days by default. Anything a conversation quotes from a file travels with it, and a hosted model you choose for a role receives what you send it.
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
Sign in
One-click browser sign-in to auth.openeng.app. Sign-in is identity only — it carries none of your code.
Compose a config
Pick an on-device coding model and the gateway checks you want in the Console; publish a versioned id@version.
Run on your engine
Start the engine with your Console API key. It dials the OpenEng Broker, the console reaches it there, and local models run inference on your own hardware.
Your engine, your machine · needs Pro
The proof
Sealed replies
Every hop is encrypted, and the engine's streamed replies are sealed end-to-end to your browser — the Broker routes your requests but cannot read those replies.
No engine telemetry
No analytics SDK, crash pings, or usage beacon in the engine.
Secrets by reference
Configs store ${ENV} references only — values resolve on the engine machine, or from an optional write-only vault stored encrypted on our servers, where the environment always wins.
Kernel-sandboxed commands
Where bubblewrap works on the host, shell commands the agent runs execute in a kernel sandbox: read-only root, writes only in the workspace, network off where the host can isolate it. Without it they run unconfined. Destructive actions need your approval by default.
Private by construction
Privacy is a property of the architecture — the models run on your machine, and between your browser and your engine, what crosses is what you exchange in the Web Console, encrypted.
Open-weight models
28 on-device catalog models through your local Ollama, or your own from any registry and format on the runtime that fits; point a role at a hosted model through the gateway if you prefer.
Persona · 02
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, once the engine's scheduler ships, run unattended on a schedule.
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
Sign in
One OpenEng account, with an API key per machine — and, once the engine’s scheduler ships, for the headless runners that have no human at the keyboard.
Compose a config
Wire agents to your cloud via cells, set guardrails and approval gates, publish an immutable id@version.
Run on your engine
Every machine started with one of your keys pulls the exact same config version; once the engine’s scheduler ships, schedulers will run it headless on cron.
The proof
20 Console domains
Building blocks, Connect, Govern, and Deploy — models, agents, skills, loops, schedulers, MCP servers, cells, connectors, gateway, roles, approval gates, API keys, and more, in one console.
No config drift
Resolve a config by id@version and every machine gets the same versioned config; the MCP servers an engine connects still come from that machine’s .mcp.json.
Approval gates
Human-in-the-loop checkpoints pause a run for sign-off before a sensitive action proceeds.
1,092 agents
810 single-purpose agents and 282 orchestrators (212 / 68 / 2 on levels 1–3), across 35 categories.
Capped runs
A resource governor (default 10% of CPU and memory) keeps each engine’s runs bounded; sandbox fleet nodes follow once they can register.
Size it yourself
Enterprise (launching Q4 2026) is sized by active sandboxes, headless slots, and schedulers — no seats, no quote call.
Persona · 03
Some people just want a capable agent that runs on their own hardware — no subscription to a model lab, no provider key to rotate, and, with local models on every role, no prompt sent to anyone's model API. OpenEng runs a whole team of open-weight models that fit your machine, with pay-as-you-go planning credit only if you use the included Cloud Planner.
The problem
Cloud assistants meter every keystroke, expire your trial, and send every prompt to someone else's model. You want the model itself on your machine — and no per-token bill when you aren't calling anyone's API.
The OpenEng workflow
Sign in
Identity once. The AI engine starts with a Console API key on Pro, which opens in Q4 2026.
Compose a config
The installer pulls a default chat model; pick the models and persona you want and publish. No provider keys to paste.
Run on your engine
Inference runs on embedded models on your machine; top up planning credit only if you use the Cloud Planner.
Install the AI engine · Linux x86_64
The proof
No provider API keys
The embedded models need no provider account and no model API key — only your OpenEng key to start the engine.
No per-token bill locally
Local inference is never metered; planning credit pays only for the included Cloud Planner.
Checked before download
Before any model download, the engine checks your RAM, free disk, and GPU presence, and refuses a model it can tell your machine can't run.
Self-routing
Every request is scored for complexity — by the built-in router, or by a Complexity Analyzer model you bind — before the engine chooses to plan or to answer directly; you never pick a mode.
Top up from $5
Pay-as-you-go planning credit for a Pro or Enterprise account comes in $5, $10, and $25 packs, charged in INR through Razorpay, and it expires; card details are never stored.
Threads everywhere
Engine-owned threads live in your engine, so that engine’s history follows you to any browser you sign in from.
The common thread
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. Local models run on your machine, and your secrets resolve there (or from the optional vault, if you choose it).
Privacy-bound builder
Files processed on the laptop.
Platform standardizer
One config governs the fleet.
Local-first power user
28 models, no provider keys.
The same shape powers the free engineering apps: Terminal, Kubernetes, Data, Git, and Chat run in your browser and drive an engine on your own machine (the Git and Chat engines are coming soon). See the apps.
Install the AI engine, start it with your Console API key on Pro (launching Q4 2026), and your browser console connects. Whatever you're building, the work runs on your machine.
Install the AI engine · Linux x86_64