# LoopX Roadmap Explained: 5 Development Tracks for the Control-Plane Dashboard

> Discover the LoopX roadmap, detailing five development tracks that will evolve the control plane into a public safe dashboard for maintainers and operators.

- Repository: [huangruiteng/loopx](https://github.com/huangruiteng/loopx)
- Tags: roadmap
- Published: 2026-08-08

---

**LoopX's roadmap centers on five development tracks that transform the CLI‑first control plane into a public‑safe front‑stage dashboard with maintainer workflows, operator‑friendly status models, and external connector showcases.**

The LoopX project (huangruiteng/loopx) is an open‑source **goal control plane** that tracks agent runs, quotas, and leases in immutable storage. Its public roadmap, documented in [`docs/product/vision.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/vision.md), maps out how the system evolves from developer‑facing commands to a polished React dashboard that non‑technical operators can trust.

---

## The Five LoopX Roadmap Tracks

LoopX organizes work into **four delivery tracks plus one cross‑cutting support layer**. Each track targets a specific surface of the product while preserving the system's **public‑safe boundary** guarantees.

### 1. Maintainer Management Surface

This track builds an **agent work feed** — a first‑screen view showing what the agent has done, what it is doing, where it is blocked, and what it needs from the user.

Key milestones include:

- Designing signal inbox cards and gate widgets (referenced in [`docs/product/vision.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/vision.md))
- Implementing the read‑only `goal_channel_projection_v0` projection defined in [`docs/product/roadmaps/frontstage-channel-lease-roadmap.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/frontstage-channel-lease-roadmap.md)

The projection is implemented in [`loopx/control_plane/goals/goal_channel_projection.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/control_plane/goals/goal_channel_projection.py) and exposes a JSON view consumed by the dashboard.

### 2. Non‑Technical Operator Status Model

Raw LoopX state — registry entries, lease records, quota consumption — gets translated into **plain‑language cards** for operators who are not developers.

The implementation renders the projection through a **React + Vite dashboard** (`apps/presentation/dashboard`) built with shadcn/ui, TanStack Router/Table/Query, and Recharts. Technology choices and UX direction are documented in [`docs/product/roadmaps/dashboard-frontend-selection.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/dashboard-frontend-selection.md).

### 3. Open‑Source Anchor Packet

This track turns issues and pull requests into **"anchor" candidates** with explicit risk assessments, evidence links, and gate contracts.

The deliverable is the `anchor_v0` contract schema, referenced in [`docs/product/vision.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/vision.md) and designed to make contributions auditable without exposing private project data.

### 4. Office‑Operations Connector Showcase

A prototype **external signal connector** ingests feeds like social media, documents, or APIs and funnels them into the LoopX control plane with **gated publishing**.

The draft connector flow appears in the *Office Operations Connectors* section of the product vision. This demonstrates how LoopX can serve as a control hub for diverse information sources while maintaining boundary controls.

### 5. Feedback & Boundary Contract

Supporting all tracks, this layer **formalizes how user feedback becomes gates, preferences, and todo updates** without leaking private data.

Critical contracts include:

| Contract | Purpose | Location |
|----------|---------|----------|
| `task_lease_v0` | Hard lease on a todo item with expiration and renewal rules | [`docs/product/roadmaps/frontstage-channel-lease-roadmap.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/frontstage-channel-lease-roadmap.md) |
| `agent_profile_v0` | Public‑safe agent identity and capability declaration | Same as above |
| `goal_boundary` | Defines what data crosses from private workspace to public projection | Same as above |

---

## Core Architectural Flow

Understanding the LoopX roadmap requires following how data moves from the control plane to the UI:

1. **Control‑Plane Core** — Immutable run history, active state, quotas, and leases live in [`loopx/registry.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/registry.py) and [`loopx/status.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/status.py).

2. **Projection Layer** — `goal_channel_projection_v0` (from [`loopx/control_plane/goals/goal_channel_projection.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/control_plane/goals/goal_channel_projection.py)) aggregates core state into a **read‑only, public‑safe view**.

3. **Front‑Stage UI** — The React dashboard (`apps/presentation/dashboard`) reads the projection via `loopx --format json status` and renders it.

4. **Dreaming Lane** — A separate `dreaming_proposal_v0` projection (documented in [`docs/product/roadmaps/dreaming-exploration-lane.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/dreaming-exploration-lane.md)) surfaces long‑horizon learning proposals as advisory badges.

5. **Feedback Loop** — User actions generate gates and todo updates that flow back into [`loopx/todos.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/todos.py) and [`loopx/quota.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/quota.py).

All layers honor the **explicit contract system** to prevent raw private data from reaching the public UI.

---

## How to Interact with Roadmap Components

### Export status for the dashboard

```bash
loopx --format json status > status.json

```

The output contains the `goal_channel_projection_v0` object that powers the maintainer management surface.

### Acquire a task lease

```bash
loopx task-lease acquire --goal-id loopx-meta --todo-id todo_user_1

```

This produces a `task_lease_v0` record required for hard‑lease scenarios in the front‑stage channel.

### Run a dreaming proposal dry‑run

```bash
loopx dreaming dry-run --goal-id my-project --limit 20

```

Returns an advisory `dreaming_proposal_v0` without mutating any state.

### Start the React dashboard

```bash
cd apps/presentation/dashboard
npm install
npm run build
npm run serve

```

The dashboard reads [`status.json`](https://github.com/huangruiteng/loopx/blob/main/status.json) (or a live HTTP endpoint) and renders the channel projection using the stack defined in [`dashboard-frontend-selection.md`](https://github.com/huangruiteng/loopx/blob/main/dashboard-frontend-selection.md).

---

## Key Roadmap Documents and Source Files

| Path | Purpose |
|------|---------|
| [`docs/product/vision.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/vision.md) | Strategic anchor defining all five roadmap tracks |
| [`docs/product/roadmaps/frontstage-channel-lease-roadmap.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/frontstage-channel-lease-roadmap.md) | Projection schema, lease contracts, and P1/P2 priorities |
| [`docs/product/roadmaps/dashboard-frontend-selection.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/dashboard-frontend-selection.md) | React stack decision and UX implementation slice |
| [`docs/product/roadmaps/dreaming-exploration-lane.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/dreaming-exploration-lane.md) | Background learning lane with permissions and schema |
| [`docs/product/roadmaps/README.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/README.md) | Aggregated index of all roadmap files |
| [`loopx/control_plane/goals/goal_channel_projection.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/control_plane/goals/goal_channel_projection.py) | Runtime builder for the projection layer |
| `apps/presentation/dashboard` | Front‑stage dashboard source code |
| [`examples/project/goal-channel-projection-smoke.py`](https://github.com/huangruiteng/loopx/blob/main/examples/project/goal-channel-projection-smoke.py) | Smoke test validating projection output |

---

## Summary

- **LoopX's roadmap** targets five tracks: maintainer surface, operator status model, anchor packets, connector showcase, and boundary contracts.
- **Public‑safe by design**: Every track uses explicit contracts (`task_lease_v0`, `agent_profile_v0`, `goal_boundary`) to separate private workspace data from public UI projections.
- **Front‑stage delivery**: The `goal_channel_projection_v0` read‑only view bridges the control plane ([`loopx/status.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/status.py), [`loopx/registry.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/registry.py)) to the React dashboard (`apps/presentation/dashboard`).
- **Dreaming lane**: A secondary projection (`dreaming_proposal_v0`) enables long‑horizon exploration without blocking operational workflows.
- **Implementation status**: Core contracts are defined; the React dashboard stack is selected; smoke tests validate the projection layer.

---

## Frequently Asked Questions

### What is the current priority in the LoopX roadmap?

The ** Maintainer Management Surface** track is the immediate focus, specifically shipping the `goal_channel_projection_v0` projection and signal inbox cards. This is marked P1 in [`docs/product/roadmaps/frontstage-channel-lease-roadmap.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/frontstage-channel-lease-roadmap.md) and provides the foundational UI that subsequent tracks build upon.

### How does LoopX keep private data out of the public dashboard?

LoopX uses **explicit boundary contracts** (`goal_boundary`, `agent_profile_v0`) enforced at the projection layer. The `goal_channel_projection_v0` builder in [`loopx/control_plane/goals/goal_channel_projection.py`](https://github.com/huangruiteng/loopx/blob/main/loopx/control_plane/goals/goal_channel_projection.py) only aggregates fields explicitly marked as public‑safe, ensuring raw workspace data never reaches the React dashboard.

### Can I run the LoopX dashboard locally without a backend server?

Yes. The dashboard reads a static [`status.json`](https://github.com/huangruiteng/loopx/blob/main/status.json) file produced by `loopx --format json status`. Build the static assets with `npm run build` in `apps/presentation/dashboard`, then serve locally. This mode supports the read‑only projection view without requiring a persistent backend connection.

### What is the "dreaming lane" in LoopX?

The **dreaming lane** is a background track for long‑horizon learning, refactor proposals, and memory consolidation. It exposes `dreaming_proposal_v0` as an advisory projection visible in the dashboard but gated separately from operational status. Documentation lives in [`docs/product/roadmaps/dreaming-exploration-lane.md`](https://github.com/huangruiteng/loopx/blob/main/docs/product/roadmaps/dreaming-exploration-lane.md).