Skip to main content
The engine · sandboxed on your machine

Open-weight models,
downloaded and run on your machine.

OpenEng’s engine downloads open-weight models from any registry — Hugging Face, the Ollama library, ModelScope, or a direct URL — and runs them isolated in a sandbox on your own hardware, on the runtime the weight format supports. Combine several as a role group, pick the right brain for every job, and ship real changes to disk through a no-bypass gate.

Open the Web Console

Install the engine

curl -fsSL https://openeng.ai/engine/install.sh | bash
Sandboxed local inference Works offline Zero API keys Zero telemetry

The model team

A role group, not one big model.

Most tools call one big model in the cloud for everything. OpenEng maps a coordinated group of roles — each tuned for its job — to open-weight models running isolated in a sandbox on your machine. Point each role at any model in your catalog — whatever its registry, format, or runtime; small models handle the easy work, bigger ones the hard parts.

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.

Chat

Holds the conversation and answers directly when a request is simple enough to need nothing else.

Coding

A code-specialist model that reads, writes, and edits real files — the brain behind every change that lands on disk.

Planner

Decomposes a complex goal into an ordered, multi-step plan before a single tool runs.

Summarizer

Compresses long context and turn history so the engine keeps a tight, relevant working memory.

Classify

Routes and labels each request — the first half of the two-stage complexity router.

Semantic map

Embeds prompts and context into vectors so the engine reasons over meaning, not keywords.

Guardrail

A resident judge that screens every tool call before it runs — destructive actions default to deny.

Reviewer

Validates each loop iteration and sub-agent result, catching mistakes before they compound.

Research

An always-on research brain that grounds answers against a local, curated corpus you crawl and index yourself.

A default group maps these roles to compact open-weight models — for example Gemma 3 4B, Qwen2.5-Coder 3B, Qwen2.5 1.5B — fetched from the Hugging Face Hub. Models load once and are shared across roles; nothing re-downloads at runtime.

Open-weight model execution

28 on-device models. Three axes, one matrix.

A model is three independent choices: the registry the weights come from, the weight format they are in, and the runtime that executes them. The format determines which runtimes can run it — the engine enforces that compatibility matrix and refuses an impossible pairing rather than silently degrading. From a 1.3 GB model on a thin laptop to a 70B on a workstation — your choice, never a bill.

Any registry, any format

Pull weights from Hugging Face, the Ollama library, ModelScope, or a direct URL — resumable, checksum-verified, and cached with LRU eviction. GGUF, Safetensors, GPTQ/AWQ, EXL2/EXL3, MLX, ONNX, and TensorRT formats are all first-class.
  • Hugging Face · ModelScope · Ollama library
  • Direct URL supported
  • Resume + checksum + cache

The runtime that fits

Each format runs on the runtimes that support it — llama.cpp for GGUF, ONNX Runtime for ONNX, vLLM, SGLang, TensorRT-LLM, Transformers, or MLX for Safetensors and quantized checkpoints, or Ollama. Local execution is sandbox-isolated on supported hosts — never on your bare host.
  • Format ↔ runtime matrix enforced
  • Sandbox-isolated execution
  • Hardware-aware selection

GPU when you have one

The same code paths accelerate on Metal, CUDA, and Vulkan — chosen at build time with a single flag. No vendor lock-in, no separate runtime.
  • Metal · CUDA · Vulkan
  • One build flag
  • Same engine, faster

Want a hosted model instead? Point any role at one — your own OpenAI-compatible API or a provider account — and the engine reaches it through one gateway, routed out through the same sandbox. Open-weight, sandboxed on your machine, is the default.

No mode-picking

It picks the right brain. You just type.

There is no mode switch to get wrong. A two-stage complexity router scores every request before a single LLM call is spent, then routes it to plan, execute, or answer outright.

stage 1 · heuristics

Cheap signals first

Fast, deterministic heuristics catch the obvious cases — length, structure, and intent markers decide most requests instantly, before any model spins up.

stage 2 · semantic gap

Then a semantic check

When heuristics are unsure, an on-device embedding measures the semantic gap between a quick answer and the real task. Past the threshold, the engine commits to a full multi-step plan.

The routing decision

  • Below threshold

    Answered directly by the chat or coding role — no plan, no overhead.

  • Above threshold

    Promoted to the planner: a real, ordered, multi-step plan with a specialist model per task.

  • Every request

    Scored once, before spending a single LLM call — routing is nearly free.

Agents that ship

It doesn't just plan. It puts files on disk.

A complex goal runs as an agent loop — up to 28 tool steps with as many as 4 sub-agents working in parallel — and every change reaches your filesystem through the Worker Execution System: a no-bypass gateway, never a raw shell.

A real agent loop

Plan, act, observe, review, repeat. The reviewer validates each iteration, so mistakes are caught before they compound across a long run.
  • Up to 28 tool steps
  • 4 parallel sub-agents
  • Reviewed every iteration

The Worker Execution System

Every action — read, write, edit, run — executes through workers behind a gateway. There is no raw shell path the agent can reach around.
  • No-bypass gateway
  • No raw shell
  • Resource-capped workers

Changes you can review

Work lands as concrete file edits on disk you can diff, keep, or revert — not a transcript that claims it did something. Agents that actually ship.
  • Concrete file edits
  • Diff, keep, or revert
  • Auditable by design

Safe to leave running

Autonomy with a hard floor under it.

An agent with file access only earns trust if it's contained. Every tool call is screened by a resident guardrail, every worker runs inside a real OS sandbox, and the dangerous defaults are off.

A resident guardrail judge

An always-on guardrail model inspects every tool call before it runs. Destructive actions and downloads are denied unless you explicitly allow them — default-deny, not default-allow.
  • Screens every tool call
  • Destructive actions → deny
  • Downloads → deny

Real kernel sandboxing

Workers execute inside a real OS-level kernel sandbox — a read-only root filesystem, the network off, and a deny-by-default profile. Confinement enforced by the operating system, not by a prompt.
  • Kernel-enforced per worker
  • Read-only root · network off
  • Default-deny profile

Private by construction

No inbound port. Encrypted end-to-end.

The engine opens no inbound port — it dials out to reach your browser, so there's nothing on the network to connect to. The channel is encrypted end-to-end, the broker only ever relays ciphertext, and the wire has no field for a secret to leak through.

  • No inbound port

    The engine binds no socket at all — it dials out to reach your browser. There is no listening port for a network or a malicious page to connect to.

  • Encrypted end-to-end

    The browser-to-engine channel is encrypted end-to-end — the broker that relays it, and anything else on the wire, only ever sees ciphertext.

  • The egress invariant

    The wire 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.

  • Zero telemetry

    Nothing about your prompts, code, or usage is collected or sent. There is no analytics endpoint, because there is no data plane.

Get the engine

One command. No keys to paste.

The installer fetches the binary and a hardware-matched model suite, then you run it. The browser console links up the instant your engine dials in and comes online.

Install

Fetches the openeng binary plus an open-weight model suite sized to your machine.

Serve

Run openeng serve to start the engine on your machine — no keys, no accounts to wire up.

Connect

Sign in to the Web Console once; it links up to your engine through OpenEng's broker the moment it comes online — no host or port to paste.

Linux · macOS · WSL

curl -fsSL https://openeng.ai/engine/install.sh | bash

Windows · PowerShell: irm https://openeng.ai/engine/install.ps1 | iex

See the full security model

Your AI team is one command away.

Install the engine, run openeng serve, and drive it from your browser. Models, secrets, and code never leave your machine.

Install the engine

curl -fsSL https://openeng.ai/engine/install.sh | bash
Open the Web Console Read the docs