Tools

AionUi: A 7×24 Dashboard for Wrangling 20+ CLI Agents

iOfficeAI's open-source AionUi turns solo CLI agents like Claude Code, Codex, and OpenCode into a coordinated team workflow through a TypeScript-based control panel. Its 32K GitHub stars reflect real adoption, not vanity metrics.

Font size

AionUi, an open-source project from iOfficeAI, has pulled in 32,229 stars on GitHub. For a niche like "Agent Dashboard," that's a meaningful number. The pitch is straightforward: whether you're running Claude Code, Codex, OpenCode, OpenClaw, or Hermes, AionUi funnels them into a single browser panel with scheduling, collaboration, and long-running task support. TypeScript across the stack, up and running with one local command.

The Problem It Tackles

CLI agents are multiplying fast. Anthropic's Claude Code, OpenAI's Codex, Google's Gemini CLI, plus community projects like OpenCode, OpenClaw, and Hermes—each one is a small worker running in a terminal. One at a time, fine. Once you have a few going, things get messy:

  • No unified view of who's running what, or how it's going
  • How does context pass between different agents?
  • How do you keep them running 7×24 without dropping the connection (close your SSH session and they're gone)?
  • How do multiple agents collaborate on a single project?

AionUi's goal is to upgrade these "solo agents" into a "team workflow"—one dashboard that recruits every CLI agent, adds scheduling, collaboration, and long-running task capabilities.

Getting Started

Installation is a single line:

npm install -g aionui

Then:

aionui init     # Initialize, interactively pick which CLI agents to connect
                # Configure API keys (Claude Code / Codex / OpenCode...)
aionui start    # Launch the Dashboard
                # → Browser opens http://localhost:3000

The layout looks like this: a sidebar lists every agent instance (each virtualized as a "workstation"), the middle shows task flow, and the right panel streams live output logs. Basic setup takes about five minutes.

Adding a new CLI agent is lightweight—just write an adapter that implements the AgentProtocol interface:

import { AgentProtocol } from '@aionui/core';

export class MyAgentAdapter implements AgentProtocol {
  async start() { /* Launch CLI process */ }
  async stop()  { /* Graceful shutdown */ }
  async send(prompt: string) { return this.cli.stdin.write(prompt); }
  async recv(): Promise { return this.cli.stdout.read(); }
}

The core design principle in one sentence: don't build the agent itself, just build the orchestration shell. That's a rare kind of restraint for a 32K-star project.

How It Works (Architecture)

Three layers, each with its own job:

Agent Adapter Layer—One adapter per CLI agent, wrapping everything into the unified AgentProtocol interface (standardized start / stop / send / recv). This is the soul of the project: it hides CLI differences underneath so the scheduling layer above only talks to the interface.

Scheduler Layer—Task queue with priority, supporting cron and event triggers. Team mode arranges multiple adapters into a DAG, with data passed through a shared workspace.

UI Layer—Built on Electron + React, virtualizing each agent instance as a "workstation." WebSocket pushes real-time logs.

What I appreciate most is the adapter layer's design choice: define the interface only, don't bind the implementation. That means any CLI agent capable of stdin/stdout communication can plug in—which is how the community has rolled out 20+ supported agents.

How does it stack up against other agent frameworks?

ProjectPositioningAionUi Difference
LangChain AgentsFramework-leaning; requires code to orchestrateAionUi is a UI shell with zero-code orchestration
AutoGenMulti-agent conversation frameworkAionUi schedules CLI processes, not direct LLM calls
OpenHandsSWE agent itselfAionUi orchestrates SWE agents, doesn't replace them
SillyTavernRoleplay frontendAionUi is engineering-focused, not entertainment

AionUi's positioning is unique: it's the "front desk" for CLI agents.

Strengths and Weaknesses

Strengths:

  • Genuinely open source (MIT), TypeScript full-stack makes it easy to extend
  • 32K stars means an active community with reasonably responsive issue handling
  • Widest CLI agent coverage (20+), broad ecosystem
  • Clean adapter pattern; low cost to add new agents

Weaknesses:

  • README is nearly empty; documentation leans heavily on issues and Discord
  • Essentially a "Swiss Army knife shell"—the real intelligence lives in the underlying CLI agents
  • Depends on a local Node environment; not friendly for pure frontend deployment
  • For a 32K-star project, stability boundaries mean it's not production-critical infrastructure

Hands-On

Cloned the repo, npm install ran clean, cold start took 40 seconds. Connected Claude Code and Codex, ran a few tasks:

Test 1: Single-agent code generation

Average response time was 3.2 seconds—indistinguishable from running the CLI directly. Expected: AionUi is just a shell, so all the latency is in forwarding.

Test 2: Team mode collaborative web scraper

Had two agents collaborate on a simple scraper project. Completion around 70%, with manual intervention needed to pass context along. Team mode isn't fully cooked yet—DAG orchestration still requires the user to manage dependencies themselves.

Test 3: 7×24 background residency

Closed the browser tab, and background tasks kept running—that part actually works. WebSocket reconnects didn't drop tasks either. This is AionUi's most valuable feature, in my view.

Performance numbers: With three agents attached, RAM hit 1.8GB. Electron + Node + three CLI child processes—that's expected, but it's rough for older laptops.

Who Should Use It

Good fit:

  1. Developers using 2+ CLI agents simultaneously—finally, a unified view
  2. Individuals who want long-running agent tasks (overnight jobs, batch processing)—7×24 background residency is a real need
  3. Studios that want to demo "AI team collaboration" to clients without building from scratch—the dashboard demos much better than a terminal

Not a fit:

  1. Users running just one CLI agent—overkill
  2. Those wanting a SaaS-hosted version—currently local/self-hosted only
  3. Production environments with strict stability requirements—it's a 32K-star project, not 320K

Editorial Take

The real value of "Dashboard for Agent" projects like AionUi isn't the UI itself—it signals something bigger: the usability barrier for CLI agents has been caught up by capability. Nobody's asking "can I use this?" anymore; they're asking "how do I use it longer, more, and collaboratively." Those 32K stars confirm a genuine need, not an awesome-list inflation play—awesome-list projects usually have polished READMEs but sparse issues, while AionUi flips it: terrible README, but issues full of real-world usage questions.

My prediction: the second half of 2026 will see a wave of similar projects die off, because Anthropic, OpenAI, and Google's own IDE integrations (Claude Code in VSCode, Codex CLI, Gemini CLI in Android Studio) will internalize "multi-agent scheduling" into their official clients. Once official clients support multi-agent, the foundation disappears for neutral orchestration layers like AionUi.

But flip it around: if the open-source CLI agent ecosystem keeps fragmenting—every model lab shipping its own CLI, plus new community projects popping up—AionUi's neutral orchestration layer actually has room to survive. Official clients will always only support their own agents, so neutrality is where the differentiation lives.

An open question: I haven't dug into the contributor distribution behind those 32K stars yet—if contributions cluster around 1-2 people, project longevity is questionable; if they're spread across 10+, AionUi will probably survive this round of culling. More data needed before calling it.

Source: https://github.com/iOfficeAI/AionUi