Recorded September 16, 2026 · Current workbench

The workbench, one feature at a time

Eleven short tours of the current interface, recorded against a live Gateway with a prepared sample project. Follow the plan, explore eight evolvable entity types, and move between Chat, Canvas, Code and Science.

Project overview · Plan & Runtime
01

Keep the whole project in view

Overview brings the living plan, Runtime activity, capabilities, candidates and project files together. Search projects from the sidebar and pick up the next step in the same workspace.

  • Living plan — switch between the progress summary and detailed plan
  • Runtime — inspect task activity and delegated agent threads
  • Eight entity types — browse capabilities and shared session notes
  • Actual project state — mounted capabilities, staged candidates and files
Five views · Shared project
02

Five views, one shared project

Overview, Chat, Canvas, Code and Science provide different ways to work with one project. Switching views keeps the project resources together.

  • Overview — plan, Runtime, evolution candidates and project files
  • Chat — describe a task and watch it get worked
  • Canvas — a node editor with a component palette: inputs, flow control, agents, data, processing
  • Code — an editor over the session workspace
  • Science — a Jupyter kernel on the same files, with a JupyterLab escape hatch
Canvas · Compose a flow
03

Wire a flow instead of describing one

The Canvas is a node editor for the times a picture beats a paragraph. Components are dragged in from a categorised palette and joined into a flow you can save and reuse — a human-facing library, separate from the agent-facing workflows.

  • Input & Output — where a flow takes in and hands back
  • Flow control — map, branch, loop, reduce, verify, checkpoint
  • Agents and Data — delegation and dataset steps as nodes
  • Processing — select, filter, sort, split, regex over records
Code · Edit project files
04

A real editor, on the session's own files

Code opens an OpenVSCode server on the project workspace. Prepare the local base image once; the first Code launch builds and starts the editor container. Later launches reuse the image and installed extensions.

  • Explorer — open the same project files available in Chat and Science
  • Full editor — search, source control, extensions, terminal
  • Per-session container — kept alive while in use and reclaimed after inactivity
Science · Run a Python cell
05

A kernel you and the agent share

Run Python on the project files and inspect the result in the Notebook panel. The REPL, JupyterLab and the agent’s code interpreter use the shared project kernel. This clip runs a small example on synthetic data.

  • Notebook — run cells, interrupt, restart, save as .ipynb
  • Compute — live GPU, CPU, memory and disk for the session host
  • JupyterLab — an escape hatch to the full interface
Eight entity types · Capabilities & memory
06

Explore all eight evolvable entity types

The Overview cards lead to the capability library and shared session notes. Library availability, session selection and candidate staging describe different states; each remains visible in its own place.

  • Skills and Tools — specialist workflows and callable actions
  • Agents — specialists available for delegation
  • Connectors — external data sources and services
  • Workflow, Memory, Environment and Plugin — reusable flows, session notes, execution contexts and integrations
Chat · Compose a task
07

Start from a card, or just say it

Four starting points cover the usual asks — review, plan, explain, investigate — and the composer underneath takes anything else. Files can be attached to the session before the run begins.

  • Starter cards — review, plan a feature, explain the architecture, investigate
  • Free-form prompt — Enter to send, Shift+Enter for a newline
  • Attach files — staged into the session workspace
Files · Activity · Inspector
08

Inspect files and follow task activity

Chat’s right-hand panel provides file previews, task activity and details of selected execution steps. The prepared sample is idle, so the recording shows the file viewer and the empty activity and inspector states.

  • Files — browse and open anything in the session workspace
  • Activity — task status and gateway connection
  • Inspector — inspect a selected execution step when one is available
Machines · Live-view launchers
09

Give the agent a screen, or a second host

The sidebar groups the Browser and Computer live-view launchers with configured remote machines and deployments. This clip shows the local launch controls; available remote hosts depend on the session configuration.

  • Browser — headful Chrome, driven over noVNC
  • Computer — a full desktop for GUI automation, over noVNC
  • Remote machines — SSH hosts that open a shell
  • Deployments — services the session has published
Providers · Model capabilities
10

One catalogue for every provider

Browse registered providers and inspect each model’s advertised tool, vision and streaming support. Provider connections and model settings can be configured from the same workbench.

  • Per-model flags — tool use, vision, streaming
  • Grouped by provider — Anthropic, Google, OpenRouter and friends
  • Add a model — register a new endpoint without a redeploy
Light & dark · Connection settings
11

Dark or light, local or remote

The theme is remembered across sessions, and the endpoint is not baked in: point the workbench at a gateway on another host, or supply a token when the gateway requires one.

  • Theme — light and dark, remembered per browser
  • Connection — change the gateway endpoint at runtime
  • Token — AGENTEVOLVER_GATEWAY_TOKEN for protected gateways
▸

Run this yourself

Prepare the base image once, then launch the Python Gateway and Vite together inside the base sandbox. For a host conda setup, follow the Frontend README.

docker build -f docker/base/Dockerfile -t agentevolver/base:latest .
scripts/run-in-sandbox.sh -- scripts/serve-ui.sh

Then open http://127.0.0.1:5173. The sandbox runs with --network host, so the container loopback is the host loopback; the UI connects to ws://127.0.0.1:9876/ws by default.

See the rest of the framework

The workbench makes a system with global evolution, living plans and a shared Runtime visible and usable.