convez.ai
AgenteAutomaçãoIntermediário
ZombieDuckling

Visionary — Central de Controle Multi-Agent Local

ZombieDuckling/visionary

Painel local-first para coordenar vários agentes de IA simultaneamente

Ver no GitHub
BomPluginScore · de 0 a 100

Dashboard desktop Electron para monitorar e controlar múltiplos agentes de IA (OpenClaw, Claude Code, Hermes, Codex) em uma única interface. Funciona 100% local, armazenando tudo em SQLite, sem dependências de nuvem ou SaaS. Interface vanilla JS com servidor Node.js mínimalista e real-time via Server-Sent Events.

Instalação

$npx convez-ai ZombieDuckling/visionary

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
0
Acompanhando
0
Saúde
85%
Último commit
há 3 dias
Versão
v2.1.0
Issues abertas
4
Contribuidores
2

Casos de uso

  • Monitorar progresso de múltiplos agentes rodando em paralelo
  • Despachar trabalho e gerenciar projetos sem alternar entre aplicativos
  • Manter histórico e logs de atividades de agentes em uma única máquina
  • Integrar diferentes stacks de agentes (OpenClaw, Claude Code, Hermes)

Veredito

Solução pragmática e minimalista para quem opera múltiplos agentes de IA localmente. Architecture clean (sem build steps, sem Express, apenas node:http nativo) e totalmente offline-first. Ideal para operadores solo ou pequenas equipes que precisam de visibilidade centralizada sem abraçar SaaS.

README

A tradução para o português deste README ainda está na fila.

Visionary

A local-first desktop mission control for multi-agent AI systems. One pane of glass for everything your agents are doing — dispatch work, watch progress, manage projects — without juggling Telegram, WhatsApp, terminals, and a dozen chat tabs.

Built as an Electron app on top of a tiny Node.js server (node:http, no Express) and a single SQLite file (better-sqlite3). Vanilla JS frontend, server-sent events for real-time updates, zero build step.

Why

Most agent dashboards are SaaS, cloud-bound, and assume a team. Visionary is the opposite: one operator, one machine, one SQLite file. Your agent activity stays on your laptop. Plug in OpenClaw, Claude Code, Hermes, Codex, or whatever multi-agent stack you're running — Visionary is the surface, not the orchestrator.

Stack

  • Runtime: Node.js 22 LTS, native node:http, no Express
  • Database: SQLite via better-sqlite3 (single file, WAL mode)
  • Real-time: Server-Sent Events (no WebSocket library)
  • Frontend: Vanilla JS + CSS, no build step
  • Desktop shell: Electron 32
  • Bridge: Optional Python bridge.py for ecosystem integrations
  • Dependencies: better-sqlite3 is the only runtime npm dep. That's it.

Quick start

git clone https://github.com/ZombieDuckling/visionary.git
cd visionary
./install.sh           # deps + native binding + links the `vision` command
vision                 # opens the dashboard (starts the server if needed)

The vision command works from anywhere once installed:

vision                 # open the dashboard in your browser
vision app             # full Electron desktop app
vision start|stop      # manage the background server
vision status          # is it running?
vision logs            # tail ~/.visionary/server.log

Prefer plain npm? npm install && npm start still works (server on http://127.0.0.1:3333), and npm run app launches the desktop shell. npm start is self-healing: a prestart preflight (scripts/ensure-native.js) checks that the native better-sqlite3 binding loads under the current Node, and if its ABI doesn't match (e.g. the committed binary was built for Electron), it rebuilds the binding once automatically — no manual npm rebuild needed.

Visionary is also installable as a Progressive Web App. On Chrome desktop, look for the install icon in the address bar after opening the dashboard. On iOS Safari, tap Share → "Add to Home Screen". Once installed, the app launches in standalone mode (no browser chrome) and caches the static shell for offline use — API calls remain network-first.

For the agent bridge:

python3 -m venv .venv
.venv/bin/pip install -e ".[dev]"   # installs from pyproject.toml
npm run bridge

Configuration

All paths are overridable via env vars — no hardcoded user directories:

Env varDefaultWhat it sets
VISIONARY_WORKSPACE$HOME/.openclaw/workspaceWhere agent briefs / memory / portfolio live
VISIONARY_NODEprocess.execPath (current node)Node binary used by the Electron shell to spawn the server
PORT3333HTTP port

The dashboard also has a Settings tab for operator-owned defaults. It persists port, workspace path, theme, and default runtime in SQLite via GET /api/settings and PUT /api/settings. Theme changes apply immediately; port and workspace changes require a server restart.

Agent dispatch is routed through src/runtimes/. Add a new runtime by exporting { buildCommand, dispatch, kill, healthcheck }, registering it in src/runtimes/index.js, and assigning an agent/default runtime in the settings/agents registry. OpenClaw remains the default runtime and its CLI arguments are unchanged.

Project layout

visionary/
├── server.js          # HTTP + SSE + API routes
├── db.js              # SQLite schema + prepared statements
├── sse.js             # Event bus + client registry
├── electron.js        # Desktop shell
├── bridge.py          # Optional Python integration bridge
├── public/            # Vanilla JS SPA (no build)
├── personalities/     # Agent character / mission docs (see below)
├── tests/             # node:test smoke tests
└── .planning/         # Phase plans, requirements, research (transparency)

Personalities

personalities/ ships with the agent character files this project was built around. They're the "soul" of the orchestrator — voice, lanes of work, escalation rules, team structure. Treat them as a starting template:

  • SOUL.md — Default operating principles for any agent in the system
  • VISIONARY.md — How an agent should think about the dashboard itself
  • MISSION_CONTROL.md — Lanes of work, daily rhythm, success criteria
  • AGENTS.md — Boot-time context every agent loads
  • IDENTITY.md — Identity scaffolding
  • TEAM.md — Sub-agent roles, specialization, escalation

Fork them, rewrite them, or strip them out. Nothing in the server imports them; they're consumed by whatever agent runtime you point at the workspace.

Roadmap and phases

Build history, requirements, and phase-by-phase plans are kept under .planning/. Read PROJECT.md, ROADMAP.md, and STATE.md to see where this is going.

Contributing

PRs welcome. Read CONTRIBUTING.md first — it covers the small-deps stance, the vanilla-JS rule, and the SQLite-only architecture (these are deliberate constraints, not negotiables).

License

MIT. See LICENSE.

Python backend migration (in progress)

Phase 0 (scaffold) complete. See docs/superpowers/specs/2026-06-09-python-backend-design.md for design and docs/superpowers/plans/ for phase plans.

To run the Python backend side-by-side with the Node server on port 3333:

python3.13 -m venv .venv
.venv/bin/pip install -e ".[dev]"
.venv/bin/uvicorn visionary.main:app --port 3344

To run tests:

.venv/bin/pytest
Ver o original no GitHub

Bom para

Relacionados