Skip to content
/
Tier B A12 UI passthrough

LobeHub

lobehub · lobehub/lobehub · ★ 78k · last commit 2026-05-26

Primitive shape 10056 total
Commands 34 Skills 10000 Subagents 2 MCP tools 20
00

Summary

LobeHub — Summary

LobeHub is a full-stack multi-agent platform (77,741 stars, NOASSERTION license, TypeScript) that bills itself as a "Chief Agent Operator" — it hires, schedules, and reports on an entire AI team, running agents 7×24 without manual hand-off. It ships as a Next.js 16 web app (self-host via Docker or Vercel) plus an Electron desktop app (apps/desktop/) plus a CLI binary (lh / lobe / lobehub, apps/cli/). The agent runtime (@lobechat/agent-runtime) supports Anthropic, AWS Bedrock, Azure, Google Generative AI, Hugging Face, Fal AI, and many more via provider SDKs. Heterogeneous agents (@lobechat/heterogeneous-agents) spawn Claude Code or Codex sub-agents in sandbox containers. The platform provides Agent Groups for parallel multi-agent collaboration, a Schedule system for unattended runs, Personal Memory (white-box editable memory), a Knowledge Base (RAG), and an IM Gateway that routes agent messages to Discord, Slack, Telegram, Feishu, iMessage, WeChat, LINE, and QQ. The skill store surfaces 10,000+ MCP-compatible tools and skills. The database layer uses Drizzle ORM with PostgreSQL. The CLI (@lobehub/cli v0.0.21) exposes 25+ subcommands covering agents, bots, memory, sessions, topics, knowledge bases, models, providers, skills, tasks, and authentication.

01

Overview

LobeHub — Overview

Origin

LobeHub is from the lobehub organization (previously best known for LobeChat, the widely-used AI chat platform). 77,741 stars, ~30 contributors (API-visible). NOASSERTION license. TypeScript + Next.js + Electron. Active as of 2026-05-26. Latest release: v2.2.0 (2026-05-18).

Philosophy

README: "LobeHub is a work-and-lifestyle space to find, build, and collaborate with agent teammates that grow with you. In LobeHub, we treat Agents as the unit of work, providing an infrastructure where humans and agents co-evolve."

Key principles:

  • Agents as Unit of Work: Not prompts or models — agents are the atomic unit
  • Chief Agent Operator: The platform hires, schedules, and reports on agents; human stays in charge without staying online
  • 7×24 Operation: Schedule-driven execution; agents run while human is away
  • Co-evolution: Personal Memory builds understanding of the human; agents adapt over time
  • White-Box Memory: All agent memory is structured and human-editable; no black-box state

Four Core Pillars

  1. Operator: Unified dashboard to manage all agents; IM Gateway so agents live where you already chat
  2. Create: Agent Builder for configuring agents; 10,000+ skills via MCP-compatible skill store
  3. Collaborate: Agent Groups for parallel multi-agent work; Pages (shared document editing), Projects, Workspaces, Schedule
  4. Evolve: Personal Memory with continual learning; white-box editable memory

Multi-Provider Support

Supported LLM providers via dedicated SDKs: Anthropic, AWS Bedrock, Azure AI, Google Generative AI, Hugging Face, Fal AI, and many more. The @lobechat/agent-runtime unifies all providers under a single interface.

IM Gateway

Agent messages can be routed to: Discord, Slack, Telegram, Feishu/Lark, iMessage, WeChat, LINE, QQ. This means agents can communicate where the human already is, not requiring the human to open a separate app.

02

Architecture

LobeHub — Architecture

Distribution

  • Web: Next.js 16 app (self-host via Docker or Vercel; cloud at lobehub.com)
  • Desktop: Electron app (apps/desktop/, electron-vite, electron-builder)
  • CLI: @lobehub/cli npm package; binary aliases lh, lobe, lobehub (apps/cli/)
  • Mobile: Responsive web routes + @better-auth/expo for mobile auth

Monorepo Structure

lobehub/
├── apps/
│   ├── desktop/          # Electron desktop app (electron-vite + electron-builder)
│   ├── cli/              # @lobehub/cli (TypeScript, bun/tsdown, commander.js)
│   └── device-gateway/   # Local device gateway service
├── packages/
│   ├── agent-runtime/           # Unified LLM provider runtime
│   ├── agent-manager-runtime/   # Agent CRUD + search + prompt ops
│   ├── heterogeneous-agents/    # Spawn Claude Code / Codex sub-agents
│   ├── builtin-tool-*/          # ~20+ built-in tool packages
│   ├── builtin-skills/          # Built-in skill definitions
│   ├── database/                # Drizzle ORM schemas + repos (PostgreSQL)
│   ├── memory-user-memory/      # Personal Memory implementation
│   ├── context-engine/          # Context management
│   ├── conversation-flow/       # Multi-turn conversation logic
│   ├── chat-adapter-*/          # IM gateway adapters (Discord, Slack, Telegram, etc.)
│   └── model-runtime/           # Model abstraction layer
├── src/
│   ├── app/                     # Next.js App Router (API routes, auth)
│   ├── routes/                  # SPA pages (main, mobile, desktop, popup, onboarding)
│   ├── features/                # Business logic features
│   ├── store/                   # Zustand global state stores
│   └── server/                  # Server services + tRPC routers
├── .agents/   # Agent definitions
├── .claude/   # Claude Code config
├── .codex/    # Codex config
├── .cursor/   # Cursor config
├── AGENTS.md  # AI coding agent guidelines
├── CLAUDE.md  # References AGENTS.md
└── GEMINI.md  # Gemini config

Backend Stack

  • Framework: Next.js 16 (App Router + SPA hybrid)
  • API layer: tRPC (type-safe)
  • Database: PostgreSQL via Drizzle ORM
  • Auth: better-auth (with Expo + passkey extensions)
  • State: Zustand
  • Data fetching: SWR

Frontend Stack

  • Web: React 19 + TypeScript + @lobehub/ui + antd + antd-style
  • Desktop: Electron (electron-vite, electron-builder, electron-log, get-windows, node-screenshots)
  • Mobile routes: Responsive React with mobile entry point (entry.mobile.tsx)

Agent Execution Stack

Human request
    → Agent Builder (creates/configures agent)
    → Agent Groups (parallel collaboration)
    → @lobechat/agent-runtime (LLM call)
         → Anthropic / Bedrock / Azure / Google / Fal / HuggingFace...
    → @lobechat/heterogeneous-agents (spawn Claude Code / Codex)
    → @lobechat/builtin-tools (20+ tool packages)
    → @lobechat/builtin-skills (skill store)

Deployment

  • docker run or docker-compose (self-hosted)
  • Vercel one-click deploy
  • Alibaba Cloud / Zeabur / Sealos
  • Docker Hub image: lobehub/lobehub
03

Components

LobeHub — Components

Application Surfaces

Surface Tech Purpose
Web App Next.js 16 + React 19 Primary web UI (self-host or lobehub.com)
Desktop App Electron + electron-vite Native desktop; window capture, screenshots
CLI (lh / lobe / lobehub) TypeScript + commander.js Programmatic access to all platform features
Device Gateway Node.js Local hardware device integration

Core Packages

Package Purpose
@lobechat/agent-runtime Unified LLM provider interface (Anthropic, Bedrock, Azure, Google, etc.)
@lobechat/agent-manager-runtime Agent CRUD, search, model/provider listing, plugin install
@lobechat/heterogeneous-agents Spawn Claude Code or Codex sub-agents in cloud sandbox containers
@lobechat/context-engine Context window management
@lobechat/conversation-flow Multi-turn conversation logic
@lobechat/memory-user-memory Personal Memory (white-box editable)
@lobechat/database Drizzle ORM schemas + PostgreSQL repositories

Built-in Tools (20+ packages)

Tool Package Purpose
builtin-tool-agent-builder In-context agent creation
builtin-tool-agent-management Agent CRUD from within chat
builtin-tool-memory Memory read/write
builtin-tool-web-browsing Web search and page fetch
builtin-tool-knowledge-base RAG knowledge base access
builtin-tool-skills Skill store access
builtin-tool-skill-store Browse/install skills
builtin-tool-task Task management
builtin-tool-cloud-sandbox Run code in cloud sandbox
builtin-tool-claude-code Claude Code integration
builtin-tool-remote-device Remote device control
builtin-tool-local-system Local filesystem/shell
builtin-tool-notebook Notebook (Pages) editing
builtin-tool-self-iteration Agent self-improvement
builtin-tool-user-interaction Pause and ask human

IM Gateway Adapters

Discord, Slack, Telegram, Feishu/Lark, iMessage, WeChat, LINE, QQ — via @lobechat/chat-adapter-* packages.

Heterogeneous Agents

Adapters for spawning external agent runtimes:

  • Claude Code adapter (claudeCode.ts) — spawns CC in cloud sandbox, handles session resume, context overflow retry
  • Codex adapter (codex.ts) — spawns OpenAI Codex in cloud sandbox

Both adapters stream events (AgentStreamEvent) and support --resume <sessionId> with automatic retry on session-not-found or context overflow.

Skill Store

10,000+ MCP-compatible skills via @lobechat/builtin-skills + skill store UI. Skills are browsable and installable from within the agent chat interface. Klavis server integration for additional skill providers.

05

Prompts

LobeHub — Prompts & Instructions

Agent System Prompts

Each agent in LobeHub has a configurable system prompt. The Agent Builder helps generate an initial system prompt based on the agent's described purpose. The @lobechat/agent-manager-runtime includes UpdatePromptParams with streaming support — prompts can be updated in real-time via tRPC.

Prompt Templates

The @lobechat/agent-templates package provides pre-configured agent templates. The @lobechat/prompts package provides shared prompt construction utilities including:

  • marketToolsResultsPrompt — format tool search results for agent context
  • modelsResultsPrompt — format available model listings for agent context

Built-in Tool Prompts

Each @lobechat/builtin-tool-* package embeds its own tool description and parameter schema. These are injected into the agent's context automatically when the tool is available to the agent. The agent does not need explicit prompt engineering to use built-in tools.

Personal Memory Context Injection

@lobechat/memory-user-memory retrieves relevant memory entries and injects them into the agent's system context before each interaction. This is automatic and transparent — no manual "remember X" instructions needed.

Self-Iteration Tool

@lobechat/builtin-tool-self-iteration enables agents to update their own system prompt based on feedback. This is how the "Evolve" pillar works in practice: the agent observes what works and modifies its own instructions.

AGENTS.md / CLAUDE.md (Dev Instructions)

The repo ships:

  • AGENTS.md — detailed development guidelines for AI coding agents (tech stack, project structure, file naming conventions, testing requirements)
  • CLAUDE.md — @AGENTS.md (redirect to AGENTS.md)
  • GEMINI.md — Gemini-specific configuration
  • .cursor/docs/ — Cursor-specific documentation including createStaticStyles_migration_guide.md
  • .codex/ — Codex configuration
  • .agents/ — agent definitions

These are for AI-assisted development of the LobeHub codebase itself, not for runtime agent behavior.

Skill Prompts (10,000+ MCP Skills)

Skills from the skill store each carry their own MCP tool definition (name, description, input schema). When a skill is installed and active for an agent, its tool definition is included in the agent's tool list. No manual prompt construction required.

Heterogeneous Agent Handoff

When spawning a Claude Code or Codex sub-agent, the parent agent constructs a task prompt that is passed as the sub-agent's initial input. The hetero.ts CLI command and @lobechat/heterogeneous-agents/spawn handle the prompt serialization into AgentPromptInput format (supporting text and image content blocks).

09

Uniqueness

LobeHub — Uniqueness

Defining Characteristic

LobeHub is the most horizontally complete multi-agent platform in the batch. It is not best-in-class on any single narrow dimension — but it is the only framework that simultaneously covers: scheduled autonomous operation, IM gateway (8 messaging platforms), heterogeneous sub-agents (Claude Code + Codex), white-box personal memory, 10,000+ MCP skills, a full desktop app with screen capture, a 25+ command CLI, and a knowledge base. The breadth is the differentiator.

White-Box Memory as Philosophy

LobeHub's "white-box memory" stance is a distinctive product opinion: all agent memory is structured and human-editable. No opaque vector store that the human cannot inspect. This directly addresses a common complaint about agent memory systems. Compared to holaOS (which accumulates rules from corrections but doesn't expose internal memory structure), LobeHub exposes every memory entry in a management UI.

IM Gateway as Primary Distribution Channel

No other framework in the batch ships 8 IM adapters. The idea that agents should live where the human already chats (Discord, Telegram, WeChat, LINE, etc.) rather than requiring the human to open a separate app is LobeHub's UX thesis. This makes LobeHub the only batch member that treats IM platforms as a first-class deployment target.

Heterogeneous Agents with Automatic Retry

The @lobechat/heterogeneous-agents package handles Claude Code and Codex sub-agents with production-grade retry logic: if the cloud sandbox is recycled (session file missing) or the context overflows, the adapter automatically retries without --resume. This is a real failure mode in production, and LobeHub handles it explicitly — no other framework in the batch does.

Platform-Managed Dispatch vs. Manager Agent

LobeHub does not designate a "Manager" agent. The platform itself acts as the Chief Agent Operator: selecting agents, assembling groups, scheduling runs, routing IM messages. This avoids the single-point-of-failure of a manager agent and allows the platform to evolve scheduling intelligence independently of agent configurations.

Self-Iteration

@lobechat/builtin-tool-self-iteration enables agents to modify their own system prompts. Combined with Personal Memory, this creates a genuine learning loop: agents observe what works, update their prompts, and accumulate personalized knowledge across sessions. No other framework in the batch explicitly implements agent self-modification.

Tradeoffs

LobeHub's breadth comes with complexity: the monorepo has 80+ packages, multiple app surfaces, and deep provider SDKs. The NOASSERTION license (likely AGPL or custom — see LICENSE file) creates commercial usage uncertainty. The star count (77,741) reflects LobeChat's historical popularity more than LobeHub's standalone adoption — the rebrand from LobeChat to LobeHub is recent (v2.x era). The Vercel/cloud dependency assumption permeates the deployment docs; truly self-hosted production deployment requires careful configuration of all services.

04

Workflow

LobeHub — Workflow

Onboarding

  1. Deploy via Docker, Vercel, or cloud; or install CLI with npm install -g @lobehub/cli
  2. Authenticate: lh login (or web UI sign-in)
  3. Configure LLM provider(s): lh provider add
  4. Create first agent: lh agent create or use Agent Builder in web UI

Standard Agent Interaction

  1. Human opens chat with a named agent (web, desktop, or CLI: lh bot message)
  2. Agent receives message; calls LLM via @lobechat/agent-runtime
  3. Agent uses built-in tools as needed (web browse, memory read/write, knowledge base, tasks)
  4. Agent posts response; Personal Memory updates if new preferences detected

Agent Group (Multi-Agent Parallel)

  1. Human creates an Agent Group with multiple specialized agents
  2. Human sends task to group
  3. Platform assembles relevant agents for the task
  4. Agents work in parallel; each contributes to shared context
  5. Results are synthesized and returned to human
  6. Platform can use Pages (shared document) for collaborative writing across agents

Scheduled Execution

  1. Human creates a Schedule for a specific agent/group + task
  2. Platform runs the agent at scheduled time (even if human is offline)
  3. Agent completes work; posts to IM gateway channel (Discord, Telegram, etc.) if configured
  4. Human reviews result when available

Heterogeneous Sub-Agent Execution

  1. Agent (or human via CLI lh hetero) triggers a heterogeneous agent call
  2. @lobechat/heterogeneous-agents spawns Claude Code or Codex in a cloud sandbox container
  3. Sub-agent executes; streams events back via tRPC ingest sink
  4. If session expired or context overflow → automatic retry without --resume
  5. Results streamed back to parent agent context

Memory Lifecycle

  1. Agent interaction generates observations about human preferences
  2. @lobechat/memory-user-memory stores structured, editable memory entries
  3. Human can view and edit memory in web/desktop UI at any time
  4. Future agent interactions retrieve relevant memory to personalize responses

IM Gateway Workflow

  1. Human configures IM gateway (Discord server, Telegram bot, Feishu app, etc.)
  2. Agent receives messages via @lobechat/chat-adapter-* adapter
  3. Agent responds in the same IM channel
  4. Agent can proactively post reports/updates to IM channels on schedule

CLI Workflow Example

lh login
lh agent list
lh bot message --agent my-analyst "Summarize last week's metrics"
lh schedule list
lh memory list
lh kb create --name project-docs
06

Memory Context

LobeHub — Memory & Context

Personal Memory (White-Box)

@lobechat/memory-user-memory implements structured, human-editable personal memory:

  • Stores observations about user preferences, working styles, and facts
  • White-box: human can view, edit, and delete any memory entry in the UI
  • Automatically injected into agent context on each interaction
  • "Continual Learning" — agents update memory entries based on interaction patterns

This is LobeHub's distinctive take on memory: no black-box vector embeddings that the human cannot inspect or correct.

Knowledge Base (RAG)

@lobechat/builtin-tool-knowledge-base provides per-agent or shared knowledge bases:

  • Documents uploaded and chunked
  • Vector search retrieval (builtin-tool-knowledge-base integrates with database layer)
  • CLI: lh kb create, lh kb list
  • Agents access knowledge bases via the built-in KB tool

Context Engine

@lobechat/context-engine handles context window management:

  • Tracks token counts across conversation turns
  • Manages context compression for long conversations
  • Heterogeneous agent retry logic handles context overflow (automatic fallback to fresh session)

Conversation Threading

@lobechat/conversation-flow manages multi-turn conversation state:

  • Topics group related conversations
  • Sessions persist conversation history
  • CLI: lh thread list, lh topic list

Database Persistence

@lobechat/database (Drizzle ORM + PostgreSQL):

  • All agents, sessions, topics, messages, memory entries, knowledge base chunks stored in PostgreSQL
  • Full persistence across sessions and restarts
  • Schema managed via Drizzle migrations

Agent Documents

@lobechat/builtin-tool-agent-documents provides document-level memory:

  • Pages (shared editable documents) persist across Agent Group sessions
  • Agents can write to and read from shared pages
  • Human can view and edit any page

State Management (Client)

Zustand stores hold in-memory client state:

  • store/agent — agent configurations and selections
  • store/aiInfra — AI infrastructure (providers, models)
  • store/tool — tool and skill state (including Klavis and LobehubSkill status)
  • store/user — user profile and preferences

Cross-Session Continuity

  • PostgreSQL provides durable storage for all conversational artifacts
  • Personal Memory persists between all sessions
  • Agent configurations persist
  • Scheduled runs access the same memory/knowledge as interactive sessions
  • Heterogeneous sub-agents can resume sessions via --resume <sessionId> (with automatic fallback)
07

Orchestration

LobeHub — Orchestration

Agent Groups (Primary Multi-Agent Pattern)

LobeHub's primary orchestration mechanism is Agent Groups:

Human request
    → Platform selects relevant agents from the group
    → Agents work in parallel on assigned subtasks
    → Results shared via common context (Pages / shared document)
    → Synthesized response returned

The platform (not a fixed "Manager" agent) assembles the right agents for each task. This is a platform-managed dispatch rather than agent-to-agent delegation.

Heterogeneous Sub-Agent Pattern

For coding and execution tasks, LobeHub spawns external agent runtimes:

Parent agent
    → @lobechat/heterogeneous-agents/spawn
        → Claude Code (claude-code adapter)
        → Codex (codex adapter)
    → Cloud sandbox container
    → Streaming events back to parent
    → Result injected into parent context

Supported heterogeneous agent types: claude-code, codex. Spawned via lh hetero CLI or automatically by parent agents using builtin-tool-cloud-sandbox.

Schedule-Driven Execution

Schedule trigger (time-based)
    → Platform runs configured agent
    → Agent executes task autonomously
    → Results posted to IM gateway channel
    → Human reviews asynchronously

This enables fully unattended 7×24 agent operation — the defining feature of LobeHub vs. interactive-only platforms.

Self-Iteration Loop

Agent executes task
    → Observes feedback (explicit or implicit)
    → builtin-tool-self-iteration
        → Updates own system prompt
        → Writes to personal memory
    → Subsequent executions use updated prompt

This is LobeHub's "Evolve" pillar — agents improve themselves over time.

IM Gateway Routing

Human message in Discord / Telegram / Feishu / WeChat / etc.
    → @lobechat/chat-adapter-* receives message
    → Routes to configured agent
    → Agent responds in the same IM channel

IM adapters: Discord, Slack, Telegram, Feishu, iMessage, WeChat, LINE, QQ.

Model-Agnostic Execution

@lobechat/agent-runtime provides a unified interface across:

  • Anthropic (@anthropic-ai/sdk)
  • AWS Bedrock (@aws-sdk/client-bedrock-runtime)
  • Azure AI (@azure-rest/ai-inference)
  • Google Generative AI (@google/genai)
  • Hugging Face (@huggingface/inference)
  • Fal AI (@fal-ai/client)
  • And more via model-runtime abstraction

Agents can be configured to use different models per task type, and Agent Groups can mix models across participating agents.

No Fixed Manager Agent

Unlike hiclaw (fixed Manager role) or aperant (sequential planning agent), LobeHub uses platform-managed dispatch. The "Chief Agent Operator" concept is implemented by the platform itself — the scheduling engine, agent group assembly, and IM gateway routing are platform services, not a designated manager agent.

08

Ui Cli Surface

LobeHub — UI & CLI Surface

Web Application (Primary Interface)

  • URL: self-hosted (Docker/Vercel) or https://lobehub.com
  • Technology: Next.js 16 + React 19 + @lobehub/ui + antd + antd-style
  • Architecture: Hybrid Next.js App Router (SSR for auth) + SPA (React Router for all main pages)

Web UI features:

  • Agent Builder: create and configure agents with auto-generated system prompts
  • Chat Interface: multi-turn conversation with any agent
  • Agent Groups: configure and run parallel multi-agent collaboration
  • Pages: shared document editing by multiple agents + human
  • Schedule: set up recurring agent runs
  • Projects & Workspaces: organize work by project; team-level workspaces
  • Memory Manager: view and edit all personal memory entries (white-box)
  • Knowledge Base: create, upload documents, browse chunks
  • Skill Store: browse and install 10,000+ MCP-compatible skills
  • Model/Provider Settings: configure LLM providers and model preferences
  • IM Gateway Settings: connect Discord, Telegram, Feishu, WeChat, etc.
  • Onboarding flow: guided setup for new users

Desktop Application (Electron)

  • Tech: Electron + electron-vite + electron-builder
  • Same React SPA as web but running in Electron shell
  • Additional capabilities via native Node.js:
    • get-windows — list and monitor open application windows
    • node-screenshots — take screenshots of windows/screen regions
    • @napi-rs/canvas — canvas drawing in native context
    • Window overlay capture (overlay.html)
    • Popup window (popup.html)
  • @lobechat/desktop-bridge and @lobechat/electron-client-ipc / @lobechat/electron-server-ipc for Electron main ↔ renderer communication
  • Device gateway client for local hardware integration

CLI (lh / lobe / lobehub)

Package: @lobehub/cli v0.0.21. Built with TypeScript + tsdown; uses commander.js.

Full command list (25+ subcommands):

Command Purpose
login / logout Authentication
status Connection/auth status
agent Agent CRUD and management
agent-group Agent Group management
bot / bot-message / bot-messengers Bot management and messaging
brief Brief/report generation
completion Shell completion setup
config CLI configuration
connect Connect to a LobeHub instance
device Device management
doc Documentation access
eval Agent evaluation
file File management
generate Code/content generation
hetero Spawn heterogeneous agent (Claude Code / Codex)
kb Knowledge base management
man Manual pages
memory Memory read/write/list
message Message management
migrate Data migration
model Model management
notify Notification management
plugin Plugin management
provider LLM provider management
search Search across agents/knowledge/memory
session / session-group Session management
skill Skill management
task Task management
thread Conversation thread management
topic Topic management
user User profile management

The CLI communicates with the LobeHub backend via tRPC client (@trpc/client) using TrpcIngestSink for streaming responses.

Comparison to Batch Peers

Framework Human interface
agent-deck Bubble Tea TUI
eigent Electron desktop (custom panels)
aperant Electron kanban
tinyagi Next.js web portal at :3000
open-claude-cowork Minimal Electron chat
multica Next.js web + Electron + React Native
hola-os macOS Electron (workspace model)
hiclaw Element Web (Matrix IM) at :18088
lobehub Next.js web + Electron desktop + CLI (25+ commands)
paperclip React+Vite web dashboard

LobeHub has the broadest UI surface in the batch: full-featured web app, Electron desktop with screen capture, a rich 25+ command CLI, and IM gateway integration that brings agents into Discord/Telegram/etc.

Related frameworks

same archetype · same primary tool · same memory type

Goose (Block/AAIF) ★ 46k
A12 UI passthrough

General-purpose AI agent (not just code) with security-first tool inspection, recipe-based shareable configurations, and 15+ LLM…

Vibe Kanban ★ 27k
A12 UI passthrough

Eliminate the overhead of planning, switching between agent terminals, and reviewing diffs by providing a single web dashboard…

1Code ★ 5.5k
A12 UI passthrough

Cursor-like desktop experience for Claude Code and Codex with cloud background agents, event-driven automations, and a full…

Crystal (stravu) ★ 3.1k
A12 UI passthrough

Manage multiple parallel AI coding sessions in isolated git worktrees from a single desktop GUI.

Maestro (RunMaestro) ★ 3.0k
A12 UI passthrough

Orchestrate unlimited parallel AI agent sessions with a keyboard-first desktop app including Group Chat coordination and Auto Run…

AgentsMesh ★ 2.1k
A12 UI passthrough

Multi-tenant workforce platform that gives every team member a squad of AI coding agents coordinated through channels, pod…