Noureddine RAMDI / OpenUI: a visual canvas for managing multiple AI agents with real-time status and session persistence

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
981 Words
github-stars typescript ai-agents cli visualization session-management

Fallomai/openui

OpenAI agents are becoming more prevalent, but managing multiple agents concurrently quickly becomes a challenge. OpenUI tackles this headache by offering a visual canvas where you can spawn, organize, and monitor AI agents running asynchronously, with a persistent layout and real-time status updates. It’s a practical tool for developers or teams juggling several autonomous AI processes, providing a clearer overview than plain terminal windows.

What OpenUI provides and how it works

OpenUI is a TypeScript-based CLI tool designed to run locally and serve a web UI on http://localhost:6969. It lets you spawn different AI agents such as Claude Code, OpenCode, or Ralph Loop and manage them on an infinite canvas.

The core idea is a drag-and-drop interface where each agent appears as a node you can rename, color-code, and organize into categories or folders. This UI manages the lifecycle of agent sessions with real-time monitoring of their states—whether running, idle, waiting for input, or calling tools.

The architecture is straightforward: a CLI written in TypeScript that launches the local server and browser UI. The UI itself handles canvas management, node positioning with snap-to-grid, and persistent storage of layout and session data so your workspace stays consistent across restarts.

Under the hood, OpenUI acts as a coordinator and visual manager rather than implementing the agents themselves. You still need the AI agent CLIs installed separately. OpenUI connects to these agents, spawns sessions, tracks their Git branch and directory context, and displays their status on the canvas nodes.

The stack is TypeScript, likely running on Node.js or Bun runtime, with a frontend web UI served locally. The repo’s design focuses heavily on developer experience by giving a visual, interactive way to handle multiple agents that otherwise would be managed via separate terminal windows or scripts.

Technical strengths and design tradeoffs

What distinguishes OpenUI is its focus on session management and real-time agent monitoring within a visual canvas. The infinite canvas supports dragging nodes freely, snapping to a grid, and persistent layout storage. Categories let you group agents by team or project, with folder sizes saved between sessions.

Real-time status updates per agent node give immediate feedback on what each agent is doing, improving observability. The display of Git branch and directory info per agent is a nice touch that helps keep context clear, especially when agents are working across multiple repos or branches.

Session management allows spawning multiple agents simultaneously and restarting them with custom arguments. Sessions persist and restore on restart, which is crucial for long-running AI workflows.

The code tradeoff is that OpenUI is a management layer dependent on separate agent CLIs. It doesn’t implement agent logic or AI models itself, so its usefulness depends on integrating well with those external tools.

From a code quality perspective, the repo uses TypeScript for type safety and likely organizes UI components cleanly to handle canvas interactions and session state. The snap-to-grid and persistent sizing hint at thoughtful UX design.

The upcoming Linear integration is an interesting planned feature that will connect agent sessions directly to Linear tickets, automating branch creation and worktree management. This will deepen the Git integration and improve workflow automation for teams.

Limitations include the need to run this locally with a browser, which might not fit all deployment scenarios. Also, the dependency on specific agent CLIs means it’s not a turnkey AI agent platform but rather a visual orchestrator.

Quick start

To get started with OpenUI, you can install it globally via npm or run it directly without installing:

# Install globally
npm install -g @fallom/openui
openui

# Or run without installing
npx @fallom/openui
bunx @fallom/openui

Once running, openUI will launch a browser session at http://localhost:6969:

  1. Run openui in your project directory.
  2. The browser opens automatically at http://localhost:6969.
  3. Click the “+” button to spawn new agents (Claude Code, OpenCode, or Ralph Loop).
  4. Click any agent node on the canvas to open its terminal interface.
  5. Drag nodes around to organize your workspace, create categories to group agents by team or project.

This minimal setup requires you to have the supported AI agent CLIs installed separately. The UI then acts as a launcher and visual monitor.

Verdict

OpenUI fills a practical gap for developers and teams working with multiple AI agents simultaneously. Its visual canvas and session persistence make managing concurrent agents less chaotic than juggling terminal windows or scripts.

The tool’s strength is in its UI and real-time session monitoring rather than AI logic itself. If you’re running multiple autonomous agents for coding, research, or automation workflows, OpenUI offers a cleaner, more organized experience.

The tradeoff is reliance on external AI agent CLIs and local browser-based usage, which might not suit all environments or production setups. But for experimentation, prototyping, or team workflows needing visibility into multiple agents, it’s a solid, pragmatic choice.

Worth trying if you want a visual management layer to coordinate autonomous AI agents without building a full platform from scratch.

→ GitHub Repo: Fallomai/openui ⭐ 155 · TypeScript