Skip to content

Roadmap

Every line on the system map keeps growing. This map shows each line's shipped stations on the left and its planned stations — dotted track — on the right. The tour below it walks through what comes next on each line, and the timeline lists every milestone, shipped or not.

  1. Five lines already run. Approvals and governed autonomy; scheduler-neutral training and a managed HPC fleet; a composable inference pipeline and vLLM serving; versioned data and features; and a Postgres backend with an event outbox.
  2. First, close the loop. Two steps finish the governed drift-to-retrain loop: route drift-triggered retrains through the approval queue, and run one complete loop as a live Flux-scheduled job with its queue wait measured.
  3. Governance: from shared roles to identities. Single sign-on and per-user identity in every audit record, then — in design — scoped, just-in-time grants for autonomous agents, re-authorised on every hop.
  4. Compute: suspend, resume, predict. One suspend-and-resume service for preemption, backfill, carbon shifting and recovery, then a fleet digital twin with a predictive autopilot.
  5. Serving: scale itself. Apply the autoscaling decisions that are computed today, activate KServe on Kubernetes, and treat LLM serving topology as runtime policy.
  6. Data and training: no skew, real adapters. Serve features online from the same views training used, run real PEFT/LoRA fine-tuning jobs, and rebuild any run from its reproducibility bundle with one command.
  7. Platform: survive a host loss, then thousands of nodes. High availability and horizontal scale-out, fleet-wide telemetry and reporting, and one versioned API across every domain.

How honest is the design record?

Plans live in 115 architecture decision records. A tool checks every Accepted record against the code — its commands against the live CLI, its modules and paths against the tree — and the build fails if an accepted record names something that does not exist. Today 61 are Accepted, 33 Proposed and 21 Partially implemented: built, with the unbuilt clause named in the record itself. Several of the "partly built" items below come from those records.

Every milestone

Filter by status or area. The solid line runs up to today; everything after it is dotted track.

Shipped

Foundations — Phases 0–18, before v0.20, 19 milestones

  • CI/CD and centralized logs. Every change is tested and deployed by CI, and all service logs land in one searchable log store.
  • Pluggable dataset backends. Pull training data from Zenodo, S3-compatible object storage or a data-plane service through one interface.
  • Model scaffolding and registry guard. Generate a new model skeleton with one command; CI rejects a broken model registry.
  • Multi-stage model lifecycle. Move models through Staging, Canary and Production aliases; serving follows the alias and reloads automatically.
  • Control plane and drift detection. Request a retrain over an API and have prediction drift detected automatically.
  • Framework adapters. Train scikit-learn, PyTorch and Hugging Face models through the same pipeline.
  • Dashboard foundations. Browse models with per-model READMEs, an artifact gallery and authenticated access in a web dashboard.
  • HPC message-bus bridge. Serve predictions to HPC clients over the facility message bus and retrain automatically when model code is merged.
  • Dashboard service controls. Start, stop and restart platform services and tail their logs from the dashboard.
  • YAML-driven model registry. Declare models in YAML with per-environment overlays; each model gets its own training deployment. Includes multi-user JupyterHub notebooks.
  • Composable inference pipeline. Requests flow through ingress, feature transformation and a model router before prediction.
  • Sysadmin approval gate. Model changes from CI wait for an administrator to approve or reject them, from the CLI or the dashboard.
  • Model-zoo webhooks and freshness. GitLab/GitHub webhooks keep the platform in sync with the model repository, with freshness badges.
  • Approval-gate metrics. Approval queue activity is exported as Prometheus metrics.
  • Per-model YAML source of truth. Each model's YAML file is the single place its configuration lives.
  • Four-area monorepo. Platform, pipelines, serving and model code live in clearly separated packages in one workspace.
  • Pipeline operations CLI. Deploy, export and scaffold pipelines from the exa CLI and a dashboard Pipelines page; options show their valid choices in --help.
  • Alerting and distributed tracing. Get Alertmanager alerts and follow requests end to end with OpenTelemetry traces in Grafana Tempo.
  • Skipper operations agent. Ask an AI operations agent to inspect and act on the platform, with confirmation before any write.

Operations and HPC — v0.20 to July 2026, 9 milestones

  • Operational observability store. Diff model versions, view lineage, drift, audit history and traffic from exa commands backed by one shared platform store.
  • Closed-loop auto-retrain. Turn on automatic retraining when drift crosses a threshold, with a dry-run preview.
  • Input embedding drift. Detect drift in the inputs themselves, not only in predictions, against a stored baseline.
  • Pipeline validation gate. Smoke-test a model's serving latency before promotion; the command fails CI on an SLA breach. Adds exa doctor self-diagnosis.
  • Smoke checks and self-healing. Deployments are smoke-checked after rollout and unhealthy containers are restarted automatically.
  • Delivery toolkit. Roll back models, run shadow and A/B tests, batch inference, explanations, hyperparameter searches, model cards and namespaces from the CLI.
  • Platform-wide fault tolerance. A shared resilience layer (retries, circuit breakers, timeouts) removes single points of failure across services.
  • HPC scheduler abstraction. Submit training to Slurm or Flux (or a mock) through one scheduler-neutral interface over SSH, with GPU/account/QoS resources and job cost linked to runs.
  • Feedback, A/B stats, FinOps. Join ground-truth labels back to predictions, analyze A/B tests with proper statistics, and track budgets and carbon emissions.

Agent-native CLI and the new dashboard — July 2026, 11 milestones

  • Agent long-term memory. The Skipper agent remembers procedures, episodes and preferences across sessions using local embeddings, with export and erase controls.
  • Agent-native CLI via MCP. Expose platform capabilities as MCP tools (exa mcp serve) with an A2A agent card; writes require explicit opt-in.
  • Conversational CLI front door. Ask questions in plain English (exa ask), get explained help (exa explain) and did-you-mean suggestions.
  • Live terminal views. Watch status auto-refresh in the terminal with inline sparklines and bars.
  • Output formats and completion. Print any command as table, JSON, YAML or CSV, and install shell completion.
  • Safe mutating commands. Preview retrains with --dry-run, confirm before changes, and have every trigger audited.
  • Config profiles and contexts. Switch between named environments (exa config use) and see where each setting came from (exa env).
  • CLI plugin system. Install third-party exa subcommands as Python packages.
  • MCP resources and prompts. Agents can read platform context as MCP resources and run guided workflows such as drift diagnosis and safe promotion.
  • Generated CLI reference. Generate the full command reference from the live CLI so docs cannot drift (exa docs).
  • Dashboard next-gen (24 features). A rebuilt dashboard with MLOps, facility, LLMOps, FinOps, governance and self-observability consoles, command palette, accessibility, i18n (EN/IT), NOC wall and embedded copilot.

Programmable MLOps and Next-Gen 40 — July 2026, 17 milestones

  • Pluggable calculation providers. Swap the formula behind carbon and cost calculations via config, inline expressions or plugins, without code changes.
  • HPC fleet management. Discover clusters, approve them before use, place jobs on the best cluster, preflight them and account GPU-hours, cost and carbon.
  • Programmable MLOps and autopilot. Extend the platform through a typed SDK, provider registry and policy-as-code, and run a self-driving autopilot with a kill switch and approval hooks.
  • Next-Gen 40 wave 1 (13 features). Dataset versioning, lineage, data contracts, prompt registry, secrets, relationship RBAC, model signing/BOM, inference engines, eval suites and gates, model gateway and KServe manifests (A1, A2, A5, B1, B2, C1, C2, C3, D3, D6, D7, E1, E2).
  • RAG and guardrails. Vector store, semantic cache, retrieval-augmented generation with citations and guardrails for injection/PII (B3, B4, B5, D8).
  • Quality and governance depth. AgentOps analytics, concept drift, model-quality SLOs, shadow and champion-challenger, fairness, EU AI Act tooling, NIST AI RMF controls and an immutable audit trail (C4-C8, D1, D2, D4).
  • Features, reproducibility, GPU. Feature store, asset-centric pipelines, reproducibility bundles, Croissant/model cards, GPU sharing, autoscaling policies and fine-tuning adapter registry (A3, A4, A6, A8, B7, E3, E5).
  • Next-Gen 40 infra waves. Policy-as-code engine, distributed and federated training, embedding lifecycle, structured output, KV-aware inference gateway and heterogeneous/hybrid HPC-cloud placement (D5, E6, B6, B8, E4, E7, E8).
  • Synthetic data generation. Generate synthetic datasets with fidelity and privacy checks; synthetic-only models are refused at promotion. Completes 40/40 first implementations.
  • Projects and workspaces. Group models, pipelines, connections, storage, members, budgets and notebooks into one project workspace, from CLI, dashboard or agent.
  • Dashboard edit parity. Create and test connections, manage project members and provision project storage from the dashboard using the same code paths as the CLI.
  • Enterprise readiness phase 0. Safe multi-writer operation: storage backend seam, concurrency-safe audit chain, atomic autopilot triggers, hardened defaults, telemetry retention and backup/restore with DR drill.
  • Enterprise foundations, first slices. Helm chart, event outbox, admission queue, OIDC token validation, key rotation, WORM audit anchor, Prometheus SD, reports, fleet what-if simulation and signed exchange packages.
  • Platform vs use-case separation. Deployment-specific models and configs live in installable use-case packs on top of a use-case-agnostic platform.
  • Whole-platform backup and recovery. Back up and restore every store (databases, object storage, config) as one bundle, on a schedule, off-site.
  • Live grid carbon intensity. Carbon accounting can use a live grid carbon-intensity feed instead of a static factor.
  • Grouped CLI help. exa --help groups commands into 12 MLOps-lifecycle panels.

Enterprise depth — July to September 2026, 15 milestones

  • Self-documenting CLI groups. Every command group shows common tasks and where to learn more; every command and dashboard action has a documented use case and example.
  • Next-gen Skipper agent. Supervisor with specialist skills, docs-grounded answers, layered write-safety tiers, self-instrumentation, monitoring memory and per-project memory scoping.
  • Enterprise dashboard rebuild. Lifecycle-organized navigation and new consoles for traffic, events, admission, scaling, providers, SLOs, secrets, feature store, fairness and autopilot.
  • Platform ops from notebooks. Govern the platform from a notebook through a single facade.
  • vLLM and vision-language serving. Serve LLMs and vision-language models through a vLLM server with token streaming, health checks, metrics and HPC or external launchers (exa serve llm).
  • Postgres datastore backend. Run platform state on Postgres instead of SQLite for multi-writer deployments.
  • Judge calibration gate. An LLM judge must be calibrated (agreement, position bias, repeatability) before its scores can gate a promotion.
  • Agent quality measurement. Measure the agent across the whole CLI for correctness, grounding, safety refusals, latency and cost, with history.
  • Correctness set. Silent-data-corruption detection that suppresses drift retrains, typed carbon signals, and a quantization parity gate before promotion.
  • Causal evidence chain. Audit events carry correlation, on-behalf-of and rollback references so an action's full chain can be reconstructed.
  • Next-Gen 40 gap closure. Live traffic mirroring for shadow deployments, enforced data contracts, lineage on training/promotion/retrain, gateway guardrails and schema-valid responses, and EU Declaration of Conformity export.
  • CI-built releases with rollback. Releases are built once in CI, deployed by digest, recorded in the audit chain, and can be rolled back even when the pipeline is red.
  • Governed autonomy prerequisites. Autonomous behaviours publish blast-radius contracts, can be set per behaviour to autonomous/review/disabled, interrupted mid-run, and telemetry is anchored into the audit chain.
  • API contract guard. Control-plane API changes become reviewable diffs; accidental interface changes fail CI.
  • CLI Console in dashboard. Run any exa command from the dashboard through generated forms, with read/admin/destructive tiers and full audit.

Under construction

Close the loop — The two steps that finish the governed drift-to-retrain loop.

  • Approval on drift-triggered retrains (planned). Route drift-triggered retrains through the human approval queue; today approval gates CI-driven model changes, while drift retrains are governed by cooldowns, storm caps, corruption checks and audit.
  • Live Flux-scheduled retrain (planned). Exercise one complete drift-to-retrain loop as a real Flux-scheduled job with measured queue wait (the adapter exists; a live closed loop has not been run).

Finish what has started — Capabilities that ship today with a named piece still missing.

  • Hosted lineage server (partly built). Ship an optional lineage-server profile to browse the provenance graph; events are already emitted.
  • Standard data-contract engine + CI step (partly built). Adopt a standard validation engine and a blocking CI data-validation step; contracts already gate training.
  • Eval gate in CI and dashboard (partly built). A blocking CI job before any alias move and a dashboard page showing the gate report.
  • MLflow prompt registry backend (partly built). Store prompts in the MLflow prompt registry in addition to the built-in store.
  • External secrets manager (partly built). Run an external secrets manager and inject secrets into every service at startup.
  • Dedicated compliance page (partly built). A standalone dashboard Compliance page (compliance currently lives inside the Governance console).
  • Online feature store for serving (partly built). An online feature store and serving that reads feature views directly, removing train/serve skew; plus scheduled materialization.
  • Hybrid search and ANN indexes (partly built). Hybrid dense+sparse search, configurable ANN indexes, and ingestion from features and drift snapshots.
  • More SLO sources (partly built). SLIs from gateway latency/errors, a serving availability probe and live Prometheus evaluation.
  • Champion-challenger naming alignment (partly built). Shadow mirroring and challenger scoring have shipped; remaining work aligns the scoreboard naming with the design before formal acceptance.
  • Standard fairness engine (partly built). Optionally adopt a standard fairness library instead of the built-in metric implementation.
  • Standard guardrail engines (partly built). Integrate established PII and policy guardrail engines alongside the built-in detectors.
  • Autoscaling actuation (partly built). Apply scaling decisions automatically (including scale-to-zero with cold-start activation); decisions are computed today but applied by an operator.
  • Constrained decoding and reasoning budgets (partly built). Constrain generation to a schema at decode time and enforce and account reasoning-token budgets in the gateway and FinOps.
  • Dashboard asset views (partly built). Browse data/model assets and their staleness in the dashboard.
  • One-command reproduction (partly built). Rebuild code, data and environment and re-run training automatically from a reproducibility bundle; today the bundle is verified and the rebuild steps are listed.
  • Encoder registry in MLflow (partly built). Keep the embedding-encoder registry as MLflow artifacts.
  • Real fine-tuning jobs (partly built). Run actual PEFT/LoRA fine-tuning on the scheduler with measured eval scores, and serve multiple adapters through the engine; the adapter registry and promotion gate exist, but fine-tuning itself does not train yet.
  • Distributed training from pipeline run (partly built). Launch distributed training directly from the standard pipeline run command.
  • Live KServe activation (partly built). Deploy models to KServe on Kubernetes; manifests are generated today.
  • Keyless signing and transparency log (partly built). Keyless Sigstore signing with a public transparency log for models and audit checkpoints; key-based signing and a WORM anchor exist.
  • Insufficient-evidence reporting (partly built). Compliance packs name their own evidence gaps instead of omitting them.
  • Carbon-aware placement benchmark (partly built). Benchmark any multi-objective carbon placement policy against a simple baseline and define a retirement criterion before shipping it built-in.
  • LLM serving topology as policy (partly built). Prefill/decode topology and routing as runtime policy, paired TTFT/TPOT SLOs, and engine/accelerator-family parity checks.
  • Dry-run everywhere (partly built). Extend dry-run, confirmation and audit to the remaining mutating commands.
  • GPU LLM serving (partly built). Originally deferred GPU feature #1; vLLM server mode shipped, GPU quantization and throughput targets pending.
  • GPU scheduling and GPU-aware serving (partly built). Originally deferred GPU feature #2; scheduler-neutral GPU resources and fractional-allocation planning exist, live GPU validation pending.
  • Elastic autoscaling (partly built). Originally deferred GPU feature #3; scaling policy decisions exist, automatic actuation pending.
  • Multi-node distributed training (partly built). Originally deferred GPU feature #4; distributed/fault-tolerant training module exists, live multi-node GPU runs pending.

Enterprise scale — High availability, identity, fleet observability and one versioned API.

  • HA and horizontal scale-out (partly built). Survive a host loss and scale out: HA Postgres/object storage on Kubernetes, live event broker fan-out, Redis coordination, worker fleets, serving autoscaling and model sharding, agent replicas, bulk HPC polling. Shipped: Helm chart with rolling upgrades, event outbox/relay, admission queue, coordination seam, non-blocking HPC wait, SSE resume, capacity aggregation.
  • Identity, tenancy and governance (partly built). Single sign-on (OIDC/SAML/SCIM), per-user identity in every audit record, cloud KMS, keyless signing, dedicated authorization service and hard per-tenant isolation. Shipped: OIDC token validation, key rotation, WORM audit anchor, OpenFGA model export, cross-tenant conformance test.
  • Fleet observability and reporting (partly built). Node and GPU telemetry across thousands of nodes, long-term HA metrics, scheduled reports and a customer-facing SLA report. Shipped: Prometheus SD from the fleet registry, collector/remote-write config, cardinality guard, alert routing with heartbeat, report generation, SLO burn-rate engine, telemetry retention prune.
  • Cohesion, contract and UI scale (partly built). One versioned API across domains, typed settings, fleet-scale tables in the UI, full localization and load/chaos test tiers. Shipped: per-domain data modules, SDK decoupling, surface contract tests, env validation, result envelope, keyset pagination primitive, agent circuit breaker, API contract guard.
  • Futuristic differentiation (partly built). Fleet digital twin with spatial view, predictive autopilot, carbon+cost bursting, 3D fleet/NOC wall, governed NL fleet copilot, cross-institution exchange, compliance-as-product. Shipped: what-if simulation, drift forecasting and root-cause classifier, carbon/cost placement providers, heatmap tile API, fleet_simulate agent tool, signed exchange packages, Annex IV/V generation.

Agent governance — Designed, not built: governed identities and brokers for autonomous agents.

  • Governance spine and capability broker (in design). Agent identities with scoped just-in-time grants, re-authorization on every hop, signed capability descriptors, guardrail boundaries and per-call cost caps.
  • Data and compute brokers (in design). Short-lived credential vending for data, agent memory as a governed dataset, hybrid retrieval, quota-reserving compute admission and a Kubernetes/Kueue adapter.
  • Suspend and resume (in design). One suspend/resume service used by preemption, backfill, carbon shifting and fault recovery.

Later — Deferred, or planned without a date.

  • GPU quantization compute (deferred). Real AWQ/GPTQ/FP8 quantization on GPU hosts; without a GPU it is recorded as provenance-only and the parity gate reports inert.
  • MCP OAuth 2.1 transport (deferred). Authenticated remote MCP access for agents on other hosts.
  • Pipeline-as-code DSL (deferred). Define pipelines in a typed DSL compiled to an intermediate representation.
  • GitOps reconcile and webhooks (deferred). Reconcile platform state from Git and emit outbound event webhooks.
  • Full-screen terminal UI (deferred). A Textual-based exa tui live dashboard.
  • Per-project JupyterHub spawn (deferred). Launch a JupyterHub notebook server scoped to a project.
  • Project label on serving metrics (deferred). Break down serving metrics per project in Prometheus.
  • Automatic memory distillation (deferred). Automatically distill procedures and reflect on episodes in the background; review queue in the dashboard.
  • Dashboard SSO and tenant switcher (planned). OIDC sign-in, tenant switcher, service accounts with scoped tokens, and step-up for governed actions.
  • Dashboard E2E and visual tests (planned). End-to-end browser journeys, visual regression, bundle budgets and preview deploys in CI.
  • Dashboard self-observability (planned). Self-hosted JS error tracking, browser tracing, web-vitals and synthetic monitoring.
  • Signed release archives (planned). Sign release archives in CI.
  • Explained placement decisions (planned). Show why a cluster was chosen (exa hpc place --explain).

Read more