OpenEng AI is a local-first agentic engine: persistent threads, named agents, autonomous multi-step execution, and connectors into your own infrastructure — configured once in the browser Console and driven from the browser, with the engine itself running on your own machine.
It is one half of the OpenEng platform. The other half is the five free engineering apps (Terminal, Kubernetes, Data, Git and Chat), which run in your browser on their own small local engines (the Git and Chat engines are coming soon) (Welcome). One OpenEng account covers both.
Status on September 25, 2026: OpenEng AI isn't live yet
The Console (console.openeng.app) and the Web Console (app.openeng.app) are published, but the services behind them aren't live yet: the OpenEng API doesn't answer OpenEng AI requests (your resources, configs, API keys, plan and engine registration), and the OpenEng Broker isn't online. Until they are, the Console can't load or save your work and no engine can register, whatever the plan. These pages describe OpenEng AI as it works once those services are live. The engineering apps don't depend on them.
Availability
The Free plan includes signing in to the Console and authoring and publishing configs. Running the engine needs an active Pro plan, which launches in Q4 2026 and can't be purchased yet. The engine is published for Linux x86_64 (on Windows, use WSL). See Plans & billing.
What you can do with OpenEng AI
- Chat, code, and run multi-step work — each config chooses what its engine serves: Chat, Coding, Agentic runs (multi-step plan-then-execute runs the engine routes to by how complex the request is), Research and Device Use, where a vision model drives the screen to finish a goal (Configs). Device Use needs an engine build with the X11 device backend, which the published Linux x86_64 engine doesn't include yet.
- Start from the catalogs — import a preset bundle of agents, models, skills, templates and cells from the Library in one action, or adopt individual agents, skills and loops from the public catalogs.
- Create agents with their own system prompts, models, and tool grants, and compose them into delegation trees (Agents).
- Design each config's execution flow on a canvas — the stages the engine runs per turn (Execution flow) — and author cron-driven schedulers, which the published engine doesn't fire yet (Schedulers).
- Compose templates from blocks — reusable prompt blueprints, versioned and publishable (Templates).
- Connect your own cloud with cells — tiny connectors deployed into your AWS / GCP / Azure (Cells) — attach integrations such as GitHub, GitLab and Jira from the Console's Connectors page, each with a declared sandbox tier (their calls don't work yet; Integrations), and define storage points in GitHub/S3/GCS/Drive for run results; the engine doesn't deliver to them yet (Storage points).
- Plug in MCP servers for extra tools (MCP servers).
- Pick your models — on-device by default, described along three axes (registry, weight format, runtime), plus hosted APIs and external CLIs through one gateway, routed per role (Models & role defaults).
- Publish it all as versioned configs you build in a guided, step-by-step builder — with diffs, a version timeline, and email sharing (Configs).
- Manage keys and machines — issue the OpenEng keys engines start with, and manage the sandbox fleet; the current engine can't register a node or run fleet work yet (API keys & sandboxes).
- Set boundaries — token budgets, directory scoping, guardrail policies (Limits & guardrails), plus gateway plugins, behavioral role rules, and Human-in-the-Loop approval gates that pause a run until a person decides.
Where things live
| Surface | What you do there |
|---|---|
The engine (openeng) | Runs on your machine. You start it with your OpenEng key; it opens no port and dials the OpenEng Broker, which connects it to the Web Console (The engine) |
| Web Console (app.openeng.app) | Pick your engine and a published config, then chat and run work on your engine (Quickstart) |
| Console (console.openeng.app) | Author, adopt and publish: configs, models, agents, templates, schedulers, cells, connectors, MCP servers, governance, API keys; adopt skills and loops (tour) |
| Billing (billing.openeng.app) | Plans, subscription and payment history (Plans & billing) |
| Website (openeng.app) | Download engines, learn, and see AI pricing (launching Q4 2026) |
| Releases (releases.openeng.app) | Release notes and version history for the app engines; the AI engine has no release feed yet |
| Catalogs (their own subdomains, such as skills.openeng.app and loops.openeng.app) | Browse the public agents, skills, templates, models, loops and more that the Console adopts from (Catalogs & IDs) |
One account spans all of them: every surface signs in through auth.openeng.app with Google, and the engine authenticates with an OpenEng key you issue in the Console.
New here?
Start with the Quickstart — sign in, learn the Console layout, publish your first config, start the engine with your key, and open the Web Console. Then take the Console tour for the map of every page, keep the engine reference at hand for commands, flags and files, and read Plans & billing for the current state of AI pricing.