# The Console

> console.openeng.app is where you configure OpenEng AI centrally: define it once, publish a version, and every engine started with one of your keys can run that configuration. No more copying setups between machines. Sign in with the same OpenEng account as everywhere else — authentication runs through auth.openeng.app. As of September 25, 2026, OpenEng AI isn't live yet.

**[console.openeng.app](https://console.openeng.app)** is where you configure
OpenEng AI centrally: define it once, publish a version, and every engine
started with one of your keys can run that configuration. No more copying
setups between machines. Sign in with the same OpenEng account as everywhere
else — authentication runs through **auth.openeng.app**
([Quickstart](ai-getting-started.md)).

> [!WARNING] Status on September 25, 2026: 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. This page describes
> OpenEng AI as it works once those services are live ([status](ai.md)).

*Figure: The console shell — Overview and Configs at the top of the left nav, then Building blocks · Connect · Govern · Deploy, with Account at the bottom; the header carries the ⌘K palette. Each guide below opens with this map pointing at its page.*

## The idea: author → publish → resolve

1. **Author** — build your blocks (models, agents, templates and the rest) on their pages and press
   **Save** in each editor's header. Then select them into a config in the guided
   [config builder](configs.md#the-config-builder). Nothing changes for your engines yet.
2. **Publish** — publish a frozen **semver version** of the config, after a validation gate and a
   human-readable diff ([Configs](configs.md#publishing)).
3. **Resolve** — the engine on your machine runs the version you pick for each session in the Web
   Console at app.openeng.app, and requests that name no config get your default config
   ([How the engine picks up what you publish](ai-getting-started.md#4-how-the-engine-picks-up-what-you-publish)).

Because versions are frozen, you publish confidently — a client can follow
the latest or pin a known-good `<id>@<version>`. Until you publish your first config, no engine serves
anything.

## Every page, and where its guide lives

The left nav has two pages on top, then four groups, then the Account area. Pages marked **Pro**
explain what Pro unlocks in place of their content while your plan doesn't include them; Schedulers,
Storage points, API keys and Sandboxes also carry a lock badge in the nav.

| Page | What it does | Guide |
|---|---|---|
| **Overview** | Your working dashboard: a first-run checklist, your configs and their publish state, building-block counts, plan meters, recent activity, and the Deploy strip | [Quickstart](ai-getting-started.md) |
| **Configs** | Create configs, build each one in the guided config builder (including its **execution flow**), publish versions, browse the version timeline | [Configs](configs.md) |
| *Building blocks* | | |
| **Library** | Preset bundles of agents, models, skills, templates and cells; importing one adds its items to your lists and selects them on a config you choose | [Library](library.md) |
| **Models** | The one place models are created: **My models** (embedded, Hugging Face, Ollama, ONNX, network and provider models) and the **Embedded catalog** | [Models & role defaults](models.md) |
| **Agents** | Browse the agent catalog, adopt or customize, or author your own: system prompts, model bindings, delegator trees, caps, tool grants | [Agents](agents.md) |
| **Skills** | Browse the skill catalog and adopt skills; configs select the ones you adopted (adopt-only for now) | [Skills](skills.md) |
| **Templates** | The block composer — compose, version, and publish prompt blueprints | [Templates](templates.md) |
| **Loops** | Browse the loop catalog and adopt global loops; configs select the ones you adopted (adopt-only for now). Iteration strategies are set per config, in its Settings step | [Loops](loops.md#global-loops) |
| **Schedulers** | Scheduled prompts meant for headless machines (**Pro**; the engine doesn't fire schedules yet) | [Schedulers](schedulers.md) |
| *Connect* | | |
| **MCP servers** | Central MCP definitions (HTTP or stdio) with `${ENV}` credentials | [MCP servers](mcp.md) |
| **Cells** | The cell catalog + registering read/write deployments in your cloud | [Cells](cells.md) |
| **Connectors** | The connector marketplace (GitHub, GitLab, Jira, Canva, ElevenLabs and more): remote integrations, each with a declared sandbox tier, that you attach to a config (their calls don't work yet). Not the same as the engineering apps' [connectors](connectors.md) | [Integrations](integrations.md) |
| **Storage points** | Delivery destinations for run results (GitHub/S3/GCS/Drive/WebDAV) (**Pro**; nothing delivers to them yet) | [Storage points](storage-points.md) |
| *Govern* | | |
| **Token limits** | Per-model / per-role / per-day budgets; a config's own per-component caps live in its builder | [Limits & guardrails](govern.md) |
| **Directories** | Directory paths + trust defaults | [Limits & guardrails](govern.md) |
| **Defaults** | Account settings: role-model defaults and resource caps (not a config) | [Limits & guardrails](govern.md#defaults) |
| **Gateway** | Guardrail policies on top of the always-on platform floor | [Limits & guardrails](govern.md) |
| **Plugins** | Gateway guards: adopt from the plugin catalog or author your own (gate, transform, observe or enrich) on the Model, Cell or Connector gateway. Built-in modules are free; external endpoints need Pro or Enterprise | [Plugins](plugins.md) |
| **Roles** | Behavioral rule sets from the roles catalog, with your own overlay rules on top (**Pro**). Not the model roles on the Models page | [Behavioral roles](roles.md) |
| **Human-in-the-Loop** | Pause a run for a person at any boundary; rules, contacts and the approval queue (**Pro**) | [Human-in-the-Loop](human-in-the-loop.md) |
| *Deploy* | | |
| **API keys** | Issue (return-once), bind, and revoke keys (scopes are recorded but not enforced yet); a key is also the OpenEng key an engine starts with (**Pro**) | [API keys & sandboxes](api-keys-sandboxes.md) |
| **Sandboxes** | Your fleet of sandbox-mode nodes — activation, allocation, run history (**Pro**; no node can register yet) | [API keys & sandboxes](api-keys-sandboxes.md) |
| *Account* | | |
| **Plan & billing** · **Preferences** | Your plan and a link to billing.openeng.app, the Light/Dark theme, and **Sign out** | [Plans & billing](account.md) |

The [execution flow](execution-flow.md) has no page of its own: you design it inside each config, in
the builder's Execution flow step.

**The command palette** — press <kbd>⌘</kbd>+<kbd>K</kbd> (<kbd>Ctrl</kbd>+<kbd>K</kbd> on Linux and
Windows) anywhere, or click *Search or jump to…* in the header. It jumps to any page and carries the
creation actions (*New model*, *New agent*, *Register cell deployment*, *New config* and more) plus
*Publish a config* and *Import a library*.

## House rules the whole Console obeys

- **Secrets are placeholders — always.** Anywhere a credential appears
  (models, cells, MCP servers, storage points, connectors, plugins), the Console stores **only an
  environment-variable placeholder** like `${PROD_CELL_KEY}` — never the
  value. Pasting a raw secret is rejected outright, client-side and
  server-side ([Security & privacy](security.md)). Each engine machine supplies the values: from its
  environment, or from the Web Console's **Placeholder values** screen; the environment wins.
- **No execution, ever.** The Console never runs, tests, or pings anything.
  Connectivity is verified on the machine that will actually do the
  work — the engine.
- **Honesty badges.** Fields the engine does not consume yet are labeled
  **"Not yet consumed by the engine"** right in the editor — the Console never
  silently promises behavior the runtime doesn't have.
- **Saving is explicit — with one exception.** The block editors (models, agents, templates,
  schedulers, cell registrations) never write to the server on their own. Each has a **Save** button
  in its header: disabled **with the reason** while the document is invalid or unchanged, a spinner
  while the save is in flight, and a success/failure toast when it lands. An **"Unsaved changes"**
  chip shows the moment you diverge from the saved state, and navigating away warns you. Your
  in-progress edits still mirror to the **browser's local storage** on every keystroke
  (crash/navigation safety) — reopening the editor offers **"Restore unsaved draft?"** with
  restore/discard. A failed save keeps the local draft; nothing is ever lost. The exception is the
  **config builder**, which saves its draft automatically after each change. Publishing always
  remains a separate, reviewed step on top.
- **Help lives behind ⓘ.** No page has a standing right-hand rail or a raw JSON view: explanations
  open from an ⓘ next to the header, and live signals (validation, required `${ENV}` names) sit
  inline next to what they describe.
- **Every list row carries actions.** List pages have trailing per-row
  **Edit** (pencil) and **Delete** (trash) icons — delete always sits behind
  a confirmation dialog. Configs **shared with you** are read-only and don't offer delete.
- **The server is the enforcement boundary.** Plan meters and disabled
  buttons in the UI mirror the server's entitlement rules; even a crafted
  request is rejected server-side (`403 entitlement_exceeded`) with the true
  used/limit figures.

If the platform API can't be reached, a banner says so, retries automatically and offers **Retry
now**; editors keep your draft locally meanwhile.

## A sane first setup

1. Create two or three **agents** you actually reuse (a coder, a reviewer, a
   note-taker).
2. Register your first **cell** (start with a read-only one).
3. Set a **token limit** as a guardrail.
4. Open **Configs**, create a config, select your agents and models in the builder, and **publish
   1.0.0**. Then start your engine with an OpenEng key and pick the config in the Web Console
   ([Quickstart](ai-getting-started.md)).