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?
| Project | Positioning | AionUi Difference |
|---|---|---|
| LangChain Agents | Framework-leaning; requires code to orchestrate | AionUi is a UI shell with zero-code orchestration |
| AutoGen | Multi-agent conversation framework | AionUi schedules CLI processes, not direct LLM calls |
| OpenHands | SWE agent itself | AionUi orchestrates SWE agents, doesn't replace them |
| SillyTavern | Roleplay frontend | AionUi 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:
- Developers using 2+ CLI agents simultaneously—finally, a unified view
- Individuals who want long-running agent tasks (overnight jobs, batch processing)—7×24 background residency is a real need
- 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:
- Users running just one CLI agent—overkill
- Those wanting a SaaS-hosted version—currently local/self-hosted only
- 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.