Roadmap

Where Vantage is heading — ideas under consideration for giving agents eyes and memory, plus what we deliberately will not do.

Where Vantage is heading. For what already works, see the changelog; for what you can write today, see the guides.

The premise — who is this framework for?

Vantage treats AI coding agents as first-class citizens. Being pleasant for humans to read matters less than letting an agent write it without mistakes and verify it on its own. That is why config files are banned, why the framework owns the UI kit and the data layer, and why vantage docs / vantage search live in the CLI — the CLI is the agent’s interface, and conventions remove the room for judgment.

Seen from that angle, today’s Vantage supports agents well in two places:

Before writing — vantage docs / vantage search / vantage add skill / AGENTS.md
Verifying statically — vantage check / vantage routes

And there is one large gap.

An agent cannot see the screen it just wrote.

Browser-to-terminal forwarding in vantage dev (console.warn / console.error and uncaught errors) is the first small window into that gap. Most of the ideas below exist to close it.

In design

Element inspector — from the screen to the agent

Hover and click an element in the browser, then tell the agent “fix this”. A staple of vibe-coding tools, but here it belongs to the framework rather than to each app.

Three parts:

Inject source locations into JSX in development only — data-vtg="src/sales/index.tsx:42:7" plus the component name. Vantage owns its UI kit, and most of it spreads {...props} straight onto the DOM, so an attribute placed on something like <DataTable /> still reaches a real DOM node.
A development-only overlay that outlines the element, labels it, and emits the selection.
vantage select so the agent picks the selection up from the CLI, with --json and a --wait that blocks until something is selected.

Production builds drop both the attributes and the overlay entirely — leaving source paths in a bundle is a straight information leak.

For tools that embed the preview in an iframe, such as Squadbase Editor, the selection is also posted over postMessage, and the overlay itself can be taken over by the host tool. Vantage owns the correctness of the position data and a minimal default UI; the polished experience belongs to the tool.

Under consideration — giving agents eyes

`vantage snap` — a structured snapshot of a page

Render each route headlessly and return structured text rather than an image.

{
  "route": "/sales",
  "state": "ready",                    // loading | ready | error | empty
  "regions": [
    { "type": "kpi",   "labels": ["Revenue", "MoM"], "values": ["$12.4M", "+8.2%"] },
    { "type": "chart", "component": "EChart",   "series": ["actual", "target"], "points": 12 },
    { "type": "table", "component": "DataTable", "columns": ["date", "store", "amount"], "rows": 0 }
  ],
  "console": [{ "level": "warn", "text": "…" }],
  "network": [{ "url": "/api/sales", "status": 500 }]
}

For an agent this is orders of magnitude more readable than a screenshot. “The table has zero rows” and “the API returned 500” are exactly the failures nobody notices until a human pastes a screenshot.

Those regions can carry meaning only because Vantage owns the UI kit, the routing, and the data layer. A general-purpose browser automation tool cannot produce this granularity, which is why we think this is the strongest bet on the list.

`vantage check --runtime` — diagnostics that need a render

Today’s diagnostics only read source. This would put the failures that require an actual render behind the same command and the same exit code.

A query stuck pending, so the page never leaves its loading state
Fetching succeeded but the table or chart is empty
An API returned 4xx / 5xx during the render
Unhandled promise rejections
An element overflowing its parent

The goal is to close the agent’s self-verification loop with an exit code — one line that says: if vantage check passes, it is safe to ship.

`vantage dev --agent` — a structured event stream

The dev server would emit HMR results, render errors, API responses, and slow queries as NDJSON on a separate channel. Human-facing terminal output stays as it is, while an agent tails the stream and learns it broke something the moment it edits. A natural extension of today’s console forwarding.

Under consideration — giving agents memory

An `intent` field on `definePage`

Let the framework hold what a page is for as structure.

export const page = definePage({
  title: "Sales dashboard",
  intent: "Spot stores missing their target by looking at daily revenue per store",
});

Comments get lost as code is rewritten; this shows up in vantage routes and lands in the manifest. The readers are “yourself thirty turns from now” and “the next agent to pick this up”. It is the per-page version of the same idea behind AGENTS.md and Agent Skills: the framework decides where memory lives.

`vantage diff` — diffing the app, not the code

routes    + /reports/monthly    - /legacy
api       ~ GET /api/sales      (POST is gone)
render    /sales  table columns 5 → 4  ("owner" disappeared)
bundle    +11.2 MB

Agents systematically miss the side effects of their own edits. This confronts them with the difference between the change they intended and the change that happened.

`vantage explain <route|file>`

Documentation in reverse, for an agent inheriting an existing app: the route, the components in use, the APIs it calls, the environment variables it depends on, and the parent layouts, on one screen. An extension of vantage routes --detail, aimed at a granularity that replaces reading the source and cuts context consumption sharply.

Under consideration — preventing the mistake

Turn errors into entry points to the docs

Vantage knows its own stack inside out — TanStack Query, Base UI, ECharts, Hono. When it forwards a browser error to the terminal, it should be able to append the next move.

[console.error] Cannot read properties of undefined (reading 'map')
 > src/sales/index.tsx:42
   ↳ data from useApiQuery is undefined on the first render. Use `data?.map`
     or branch on isLoading → vantage docs data-fetching

Agents stumble hardest at “what should I even search for”, so the error itself should pull up the documentation.

Absorb common mistakes instead of diagnosing them

A generalization of how the UI kit already absorbs Base UI’s Select quirks. A diagnostic that fires often is a candidate for being made to just work. We want to treat “how often agents get this wrong” as a metric for improving the framework.

`vantage check --budget`

Fail the build on bundle-size or first-render regressions. Agents add heavy dependencies without hesitation — a single Markdown renderer can add more than 10 MB of output. This turns the unease a human would feel into a threshold a machine can read.

Scaffolding from the shape of the data

Hand it an API response or a SQL result and get back a page skeleton suited to that shape: a line chart for time series, a table plus KPIs for category × value, and so on. Agents redo this judgment from scratch every time; the conventional answers belong in the framework.

What we deliberately will not do

What is not on a roadmap matters just as much, so here is the current position.

Config files. There will be no vantage.config. When something seems to need configuration, we first ask whether a convention or a flag can solve it. Room for judgment is a liability for an agent.
A swappable stack. React, the router, the data layer, and the UI kit are fixed by Vantage. The moment swapping is allowed, the docs, the skills, and the diagnostics all have to assume they do not know what you are using — and nearly every idea above stops working.
Replacing the QueryClient wholesale. Customization happens per query (see data fetching).
Becoming a general-purpose application framework. Vantage is a framework for dashboards. Rather than broadening the scope, we would rather step on every landmine dashboards have to offer.

Feedback

We would rather prioritize the list above from real friction. If you hit a spot where the agent always gets it wrong, or where you were stuck because something was not discoverable, please tell us.