Direct questions, direct answers

OpenEng is an agentic ecosystem for open-weight model execution: it downloads, orchestrates, and runs open-weight (open-source) AI models entirely on your machine. A local engine holds the models, the agent loop, your threads, and your secrets; you drive it from the browser Web Console over an end-to-end-encrypted channel. There is no telemetry. The engine is free; a Pro plan (launching Q4 2026) adds schedulers, headless automation, and fleet coordination.

Open-weight means the model’s trained weights are published for download, so you can run the model yourself — which is exactly what OpenEng does, on your own hardware. “Open source” in the strict sense (the OSI Open Source AI Definition) is a higher bar that also covers training data and process. Most downloadable models people call “open source” are, precisely, open-weight. OpenEng uses “open-weight” for accuracy and treats “open-source models” as the common synonym. Note: the models are open-weight; the OpenEng platform itself is not open source.

A model is described along three decoupled axes: the registry it comes from (Hugging Face, Ollama library, ModelScope, direct URL), the weight format it is in (GGUF, Safetensors, GPTQ / AWQ, EXL2 / EXL3, MLX, ONNX, TensorRT), and the runtime it executes on (llama.cpp, ONNX Runtime, vLLM, SGLang, ExLlama, MLX, TensorRT-LLM, Transformers, Ollama) — the format determines which runtimes can run it. You can combine several open-weight models in one config as a role group — a small model for chat, a coding model for edits, another for planning — so each job runs on the right-sized model. The on-device catalog has 28 open-weight models to pick from, from about 1.3 GB to a 70B.

Largely, yes. Once the models are on disk, inference, planning, coding, review, embeddings, and memory all run on your machine with no network call. The network is used for sign-in, fetching your published config (cached for short offline stretches), downloading new models, and the self-update check.

Today: a native Linux x86_64 engine, installed with one checksum-verified line. Windows can run it under WSL now; native macOS (Apple Silicon) and Windows builds are coming soon. A desktop companion follows later — the engine is the product that is live.

They are three independent choices. The registry (Hugging Face, Ollama library, ModelScope, direct URL) is where the weights come from. The weight format (GGUF, Safetensors, GPTQ / AWQ, EXL2 / EXL3, MLX, ONNX, TensorRT) is what the weights are. The runtime (llama.cpp, ONNX Runtime, vLLM, SGLang, ExLlama, MLX, TensorRT-LLM, Transformers, Ollama) is how they execute. The format determines which runtimes can run a model — GGUF runs on llama.cpp or Ollama, ONNX runs on ONNX Runtime, Safetensors runs on vLLM, SGLang, TensorRT-LLM, Transformers, or MLX, and so on. The engine enforces that compatibility matrix — it refuses an impossible pairing instead of silently degrading. Local models run isolated in a sandbox on your machine — never on your bare host. Hosted and cloud models are reached through one gateway and routed out through the same sandbox.

Yes — the Ollama library is one of the registries the engine pulls from, and Ollama is one of several runtimes you can select per role. Point a role at a model in your local Ollama library and OpenEng runs it through the same role system as every other model. If you author an Ollama model with a public tag, the engine pulls it for you at provisioning.

Yes. The engine fetches open-weight model weights from the Hugging Face Hub — resumable, checksum-verified, and cached with LRU eviction — then runs them isolated in a sandbox on your machine, on a runtime the weight format supports. Point a config at a public repo and file and the engine provisions and warms it up. ModelScope and direct URLs work the same way.

Yes. ONNX models execute on ONNX Runtime, locally on your CPU (GPU execution providers follow), sandboxed like every local model. Standard Optimum / onnx-community export layouts are supported; the engine downloads model.onnx, the tokenizer, and config from a Hub repo and decodes locally. TensorFlow models are supported via ONNX export.

Yes, as a secondary option. Point any role at a hosted model — your own OpenAI-compatible API, or a hosted provider account. Every hosted and cloud call goes through one model gateway and is routed out through the same sandbox as everything else, so it is a single auditable choke point. The default and the pitch remain open-weight models running sandboxed on your machine; a hosted model is something you opt into per role.

The engine sizes models to your CPU, RAM, and GPU, and runs under a hard resource budget (a small fraction of the machine by default, tunable). Open ten sessions and the on-device models load once and are shared. Optional GPU acceleration is a single build-time choice.

Run: curl -fsSL https://openeng.ai/engine/install.sh | bash — it downloads the prebuilt Linux x86_64 binary, verifies its SHA-256 checksum, and puts openeng on your PATH. A default open-weight model is pulled on first run; you can defer model downloads and let each config pull what it needs. You can also download the raw binary and checksum from openeng.ai/download and verify manually.

Yes — one OpenEng account, signed in once. Interactive sign-in is through the browser; servers use API keys. The account carries your plan (Free or Pro) and your Console-published configs. Your actual work — code, prompts, threads, memory, and the models themselves — stays on your machine and is not synced to our servers.

The engine is free, including downloading and running open-weight models, the agent loop, threads, and memory. Pro (launching Q4 2026) unlocks schedulers, headless automation, cloud-coordinated sandboxes, and human-in-the-loop approval gates. Pay-as-you-go token credit (for hosted models) tops up from $5. Pricing is announced at launch.

No — not unless you explicitly point a role at a hosted model, and even then the call leaves through one auditable gateway. Local models run isolated in a sandbox on your machine, and inference, embeddings, memory, and the file tools all run locally. The browser Web Console is a thin client that never receives a model, a memory, or a secret; the channel to your engine is end-to-end encrypted and relayed by a broker that only ever sees ciphertext.

No. There is no telemetry in the engine — no analytics SDK, no usage beacon, no crash phone-home. What exists server-side is your account: sign-in identity, plan state, and the configs you publish. This marketing website uses aggregate web analytics (described in our privacy policy); the engine itself does not.

On your disk, in plain files under your OpenEng home directory: thread metadata, the transcript, and the rolling memory. Credentials live in a private, permission-restricted file. Delete the directory and the data is gone — there is no cloud copy.

Configs never contain secret values — they reference ${ENV} placeholder names, and the engine resolves the real values from your local environment at run time. A breach of the control plane yields names, not values. Server API keys are stored hashed on the platform side and validated per call.

Yes — that is headless mode (Pro). It runs cron-validated jobs with no terminal and no browser, authenticated by an API key, logging to an append-only file. Startup gates verify the config allows headless, that every model role resolves, and that at least one scheduler exists — otherwise it refuses to start with an explicit reason.

One published config resolves by id@version, byte-identical on every machine that signs in — no drift. Interactive sign-ins are single-session per account with explicit takeover; servers use API keys, which are concurrent and multi-machine by design. One Pro subscription follows the account everywhere.

The engine self-updates from the release service: the new binary is checksum-verified, applied as an atomic swap, and re-execed at boot. A failed or tampered download changes nothing — the running binary stays untouched until the new one is proven.

Most AI tools are clients for a cloud model API: every prompt and file they read transits a provider, and you pay per token. OpenEng inverts that. It downloads open-weight models from any registry and runs them isolated in a sandbox on your own machine, with no telemetry; a hosted provider is an explicit per-role choice routed through one gateway rather than the foundation. Pro is a flat subscription (launching Q4 2026) instead of metered tokens.

No — you work in chat, in the Web Console. Slash commands run inside the chat itself: /template applies a prompt template, /agent switches the active agent, /loop picks a loop strategy, /skill invokes a named skill, and /role targets a model role. There are no “modes” to pick; the engine scores each request’s complexity and self-routes plan-vs-execute.