Skip to content
/
Tier B A12 UI passthrough

AiderDesk

aiderdesk · hotovo/aider-desk · ★ 1.2k · last commit 2026-05-26

Primitive shape 9 total
Commands 1 Skills 3 Subagents 4 MCP tools 1
00

Summary

AiderDesk — Summary

AiderDesk is an open-source Electron desktop application that began as a GUI for the Aider CLI but evolved into a full "transparent, steerable AI orchestration platform" — providing multi-project management, Git worktree isolation, vector-embedding context management, subagent delegation, 30+ LLM provider support, a lifecycle extension system, MCP client/server, and an extensible skills system.

Problem it solves: Aider (the CLI) is powerful but terminal-only; more importantly, professional developers need control over AI changes (review before apply, approval gates, context precision) that CLI tools don't provide. AiderDesk surfaces every proposed change for inspection and provides trust boundaries the CLI lacks.

Distinctive trait: The extension system is uniquely powerful — extensions can hook into 30+ lifecycle events (onTaskCreated, onPromptFinished, onToolCalled, onFileAdded...), inject TypeScript functions as custom AI tools, and render React components directly into the chat interface. No other tool in this batch or any seed framework has this level of extensibility at the application layer.

Tech stack: Electron + React 19 + TypeScript + Tailwind CSS (renderer), TypeScript + Vercel AI SDK (main process), Python (Aider subprocess), LanceDB (vector embeddings), SQLite (local storage). Multi-platform: Windows, macOS, Linux.

Target audience: Professional developers using Aider CLI who want a visual control plane, enterprises requiring audit trails and approval gates, and teams wanting to extend AI coding behavior with custom tooling.

Production-readiness: 1,233 stars, Apache 2.0, 16 contributors; actively maintained (pushed May 2026 same day as analysis). Full docs at aiderdesk.hotovo.com.

differs_from_seeds: AiderDesk is the only batch framework with a real extension marketplace (35+ examples), lifecycle hooks, and TypeScript-defined AI tools injected at runtime. It ships its own .aider-desk/ Claude Code primitive set (commands, skills, agents) for its own development — a meta-level application of the methodology it enables.

01

Overview

AiderDesk — Overview

Origin

AiderDesk is built by Hotovo (hotovo.sk), a Slovakia-based software development company. It has 16 contributors with primary author wladimiiir. The project has detailed documentation at aiderdesk.hotovo.com and an active Discord community. v1.0 was built as a GUI for the Aider CLI; subsequent versions evolved it into an orchestration platform.

Philosophy

Three principles guide AiderDesk, from the README:

Principle Description
Transparency "See every token, every context file, and every proposed change before it lands. Nothing happens in the dark."
Control "The AI is a junior pair programmer, not an autopilot. Approve tools, authorize destructive actions, fork tasks, and surgically edit chat history."
Flexibility "Keep your IDE. Keep your terminal. Keep your Git workflow. AiderDesk slides in alongside your existing toolchain — no disruption, no lock-in."

The "junior pair programmer" metaphor is the core philosophical stance: AI should propose, humans should decide. This differs from tools like superpowers (which auto-executes) or BMAD (which directs personas). AiderDesk deliberately inserts human checkpoints at every consequential action.

Evolution from Aider GUI

AiderDesk started as a graphical front-end for the Aider CLI (the popular AI coding assistant that predates Claude Code). The codebase still contains first-class Aider integration (aider_tools, aider-manager.ts, python-dependencies-installer.ts) alongside a full independent AI agent stack. Users can run Aider through AiderDesk or use AiderDesk's own agent (which calls LLM APIs directly via Vercel AI SDK).

Notable design choices

  1. Handlebars prompt templates instead of static prompts — allows project-specific customization
  2. LanceDB vector embeddings for semantic context file selection — not keyword-based
  3. TypeScript extension API that allows injecting code-defined AI tools at runtime
  4. Two connector IDE plugins (IntelliJ + VS Code) for bidirectional context sync
  5. REST API for external integration, unlike any other batch tool
02

Architecture

AiderDesk — Architecture

Distribution

  • Electron desktop app for Windows, macOS, Linux
  • Docker image
  • npm install via npx @aiderdesk/extensions install (for extensions)
  • IntelliJ plugin: JetBrains Marketplace
  • VS Code plugin: VS Code Marketplace

Directory structure

aider-desk/
├── src/
│   ├── main/                          # Electron main process (TypeScript)
│   │   ├── app.ts                     # App entry
│   │   ├── agent/                     # Core AI agent
│   │   │   ├── agent.ts               # Main agent class (Vercel AI SDK)
│   │   │   ├── tools/                 # Tool implementations
│   │   │   │   ├── power.ts           # file-read/write/edit/bash/glob/grep
│   │   │   │   ├── aider.ts           # Aider integration tools
│   │   │   │   ├── memory.ts          # Memory CRUD tools
│   │   │   │   ├── skills.ts          # activate-skill tool
│   │   │   │   ├── tasks.ts           # run-task, search-parent-task
│   │   │   │   └── todo.ts            # Todo management tools
│   │   ├── extensions/                # Extension system
│   │   │   ├── extension-manager.ts
│   │   │   ├── extension-loader.ts
│   │   │   ├── extension-registry.ts
│   │   │   └── extension-context.ts
│   │   ├── skills/                    # Skills system
│   │   │   └── skill-manager.ts       # Loads SKILL.md from global + project dirs
│   │   ├── memory/                    # Memory system
│   │   │   └── memory-manager.ts
│   │   ├── prompts/                   # Handlebars prompt template system
│   │   │   ├── prompts-manager.ts     # Template compilation + watching
│   │   │   └── types.ts               # Template types (CodeChangeRequests, HandoffPrompt...)
│   │   ├── project/                   # Project management
│   │   ├── task/                      # Task lifecycle
│   │   ├── worktrees/                 # Git worktree management
│   │   ├── mcp-server/               # AiderDesk as MCP server
│   │   └── ...
│   ├── renderer/                      # React frontend
│   └── mcp-server/                    # MCP server package
├── packages/
│   └── common/                        # Shared types and utils
├── .aider-desk/                       # Built-in AiderDesk development config
│   ├── agents/                        # Built-in sub-agents (code-checker, etc.)
│   ├── skills/                        # Built-in skills (writing-tests, etc.)
│   └── commands/                      # Built-in commands (update-changelog.md)
└── docs-site/                         # Documentation site source

Technology stack

Layer Technology
Desktop shell Electron
Frontend React 19 + TypeScript + Tailwind CSS
AI agent runtime Vercel AI SDK (ai package) with streamText/generateText
Aider subprocess Python 3 (spawned via Node subprocess)
Vector embeddings LanceDB (semantic file search)
Local storage SQLite
Prompt templates Handlebars
Extensions TypeScript (runtime-loaded)
Formatting Biome
Testing Vitest

Data flow

  1. User creates Project + Task in AiderDesk
  2. Task initializes a Git worktree (optional)
  3. Agent receives user prompt + context files
  4. Vercel AI SDK streams LLM response with tool calls
  5. Tool calls (file read/write/bash/Aider) go through Approval Manager
  6. Approval Manager shows GUI dialog before executing destructive ops
  7. Changes written to worktree (not main branch)
  8. Diff viewer surfaces all changes for review
  9. User reviews and optionally merges worktree back
03

Components

AiderDesk — Components

Claude Code primitives (for AiderDesk's own development, in .aider-desk/)

Commands

  • update-changelog.md — Update the project changelog

Skills

  • agent-creator — Create new agent definitions for AiderDesk
  • theme-factory — Create custom UI themes
  • writing-tests — Write Vitest unit/component/integration tests (SKILL.md with progressive disclosure)

Sub-agents

  • code-checker — Check code quality
  • code-reviewer — Review code changes
  • test-writer — Write tests
  • translation-manager — Manage UI translations

Internal AI toolset (Vercel AI SDK tool())

Power tools

Tool Purpose
power/file-read Read file contents
power/file-write Write file contents
power/file-edit Edit existing file
power/bash Execute shell command
power/glob Pattern-match file paths
power/grep Search file contents
power/semantic-search Vector embedding search via LanceDB

Aider tools (delegate to Aider subprocess)

Tool Purpose
aider/get-context-files Get files in Aider context
aider/add-context-files Add files to Aider context
aider/drop-context-files Remove files from context
aider/run-prompt Send prompt to Aider subprocess

Memory tools

Tool Purpose
memory/store Store key-value memory
memory/retrieve Retrieve memory value
memory/list List all memory keys
memory/delete Delete memory entry

Skills tools

Tool Purpose
skills/activate-skill Load a SKILL.md into context

Task tools

Tool Purpose
tasks/run-task Spawn a sub-agent task
tasks/search-parent-task Search parent task context

Todo tools

Tool Purpose
todo/get-items Get todo list
todo/set-items Set todo items
todo/update-item-completion Mark item done
todo/clear-items Clear all todos

Extension system

Extensions hook into 30+ lifecycle events and can:

  • Override lifecycle behaviors: onTaskCreated, onPromptFinished, onToolCalled, onFileAdded, etc.
  • Provide custom TypeScript AI tools: Functions exposed directly to the AI agent
  • Inject React components: Custom UI widgets in the chat interface

35+ example extensions in the extension gallery at aiderdesk.hotovo.com/docs/extensions/.

Prompt template system

PromptsManager uses Handlebars templates for all system prompts:

  • CodeChangeRequestsPromptData — main agent prompt
  • CommitMessagePromptData — git commit generation
  • CompactConversationPromptData — context compaction
  • ConflictResolutionPromptData — merge conflict handling
  • HandoffPromptData — context handoff
  • InitProjectPromptData — project initialization
  • TaskNamePromptData — task naming

Templates can be overridden globally (~/.aider-desk/prompts/) or per-project (.aider-desk/prompts/).

MCP integration

  • MCP client: Connect any MCP server to provide additional tools to the agent
  • MCP server: AiderDesk exposes itself as an MCP server (src/mcp-server/) for external clients (Claude Desktop, Cursor)

IDE connector plugins

  • IntelliJ IDEA: Sync context files between IDE and AiderDesk
  • VS Code: Sync context files between VS Code and AiderDesk
05

Prompts

AiderDesk — Prompts

AiderDesk uses a Handlebars-based prompt template system. All system prompts are customizable per project. The following excerpts come from the in-repo skill and source files.

Excerpt 1 — writing-tests SKILL.md (built-in skill)

Prompting technique: Progressive disclosure SKILL.md with frontmatter metadata, quick-start examples, core pattern links, and troubleshooting guidance. Uses [references/file.md](references/file.md) links for deep dives rather than embedding all content.

---
name: writing-tests
description: Write unit tests, component tests, and integration tests for AiderDesk 
using Vitest and React Testing Library. Use when creating new tests, adding test 
coverage, configuring mocks, setting up test files, or debugging failing tests.
---

# Writing Tests

Write effective tests using Vitest and React Testing Library.

## Quick Start

Create a unit test in `packages/common/__tests__/utils/math.test.ts`:

```typescript
import { describe, it, expect } from 'vitest';
import { add } from '../../utils/math';

describe('math utility', () => {
  it('adds two numbers correctly', () => {
    expect(add(1, 2)).toBe(3);
  });
});

Run tests with npm run test.

Core Patterns

Unit Testing

Focus on pure functions and logic in src/main or packages/common. Use vi.mock() for dependencies.

Debugging Failing Tests

  1. Read the error output and identify the failing assertion
  2. Check mock setup — verify vi.mock() paths and return values match expectations
  3. For component tests, inspect rendered output with screen.debug()
  4. Run a single test: npm run test:node -- --no-color -t "test name"

**Key technique:** SKILL.md with YAML frontmatter (`name` and `description` required for discovery). Quick Start gives a copy-paste example immediately; references deep-link to additional content only when needed (progressive disclosure). The structure mirrors the superpowers/spec-kit skill format but adapted for Vitest.

## Excerpt 2 — Handlebars prompt template system (from prompts-manager.ts)

**Prompting technique:** Dynamic template compilation with project-specific overrides. Templates are compiled at startup and cached; project-specific versions override global defaults.

The `PromptTemplateName` enum in `types.ts` reveals all template types:
```typescript
enum PromptTemplateName {
  CodeChangeRequests = 'code-change-requests',
  CommitMessage = 'commit-message',
  CompactConversation = 'compact-conversation',
  ConflictResolution = 'conflict-resolution',
  ConflictResolutionSystem = 'conflict-resolution-system',
  Handoff = 'handoff',
  InitProject = 'init-project',
  TaskName = 'task-name',
  UpdateTaskState = 'update-task-state',
}

Override path: .aider-desk/prompts/<template-name>.hbs (project) → ~/.aider-desk/prompts/<template-name>.hbs (global) → built-in default.

Key technique: Project-scoped prompt override pattern. Project teams can customize the exact prompts the AI receives without forking the application. This is unique in the batch — other tools use static prompts.

Excerpt 3 — skills/activate-skill tool (from skill-manager.ts)

Prompting technique: On-demand progressive disclosure — skills are loaded only when the AI explicitly calls activate-skill, not pre-loaded. The SkillManager.loadAllSkills() method scans global and project skill directories, parses YAML frontmatter, and returns { name, description } pairs for tool selection. Full skill content loads only when activated.

const parseSkillFrontMatter = (markdown: string): { name: string; description: string } | null => {
  const parsed = loadFront(markdown);
  const name = typeof parsed.name === 'string' ? parsed.name : undefined;
  const description = typeof parsed.description === 'string' ? parsed.description : undefined;
  if (!name || !description) return null;
  return { name, description };
};

This implements the same progressive disclosure pattern as the superpowers writing-skills skill — surface summary (frontmatter description), load full content only when needed.

09

Uniqueness

AiderDesk — Uniqueness & Positioning

differs_from_seeds

AiderDesk has the most feature overlap with the seed corpus of any batch-21 tool — but in unexpected ways:

  • vs. superpowers (Archetype 1): Both emphasize TDD and workflow discipline, but superpowers injects methodology via skills; AiderDesk enforces control via approval gates and diff review. Neither approach requires the other.
  • vs. claude-flow (Archetype 3): Both support multi-agent delegation and persistence. claude-flow uses MCP + SQLite; AiderDesk uses Vercel AI SDK + LanceDB. AiderDesk has better human-in-loop; claude-flow has more automated orchestration.
  • vs. kiro (Archetype 5): Both emphasize spec-first development and task isolation; kiro uses IDE-native hooks and EARS notation; AiderDesk uses worktrees, approval gates, and a TypeScript extension API. AiderDesk is open-source; kiro is commercial.
  • vs. taskmaster-ai (Archetype 3): Both support task decomposition and context management; taskmaster-ai focuses on task breakdown via MCP; AiderDesk focuses on per-task isolation and review.

AiderDesk is closest to a bridge between Archetype 3 (MCP-toolserver) and Archetype 5 (closed IDE) — it has the extensibility of a toolserver and the visual control of an IDE, but as an open-source desktop app that wraps an external coding CLI (Aider).

What distinguishes AiderDesk in the entire corpus

  1. TypeScript extension system — 30+ lifecycle hooks + injectable React components. No other framework in Phase B or Phase D allows this level of application-layer extensibility. Extensions can add custom UI, custom tools, and behavioral overrides.
  2. LanceDB vector context — Semantic file selection via local vector embeddings is not documented in any other batch tool.
  3. Handlebars prompt override — Project-specific prompt templates allow teams to customize the AI's behavior without forking the codebase.
  4. Multi-provider — 30+ LLMs including local (Ollama). The only batch tool that is model-agnostic in this way.
  5. Wraps Aider not Claude Code — Uniquely, AiderDesk's primary coding engine is Aider CLI (paul-gauthier/aider), not Claude Code. It targets the Aider ecosystem while offering Claude Code as one of many providers.

Positioning within the batch

AiderDesk is the most technically comprehensive tool in the batch — it provides the most features, the most extensibility, and the most control. However it also has the highest setup complexity (Python + Aider required, complex tool approval configuration, extension development overhead).

Among the GUI tools in this batch:

  • Simplest: Anima (4 MB, vanilla JS)
  • Most focused: Poirot (read-only session viewer, 6 MB)
  • Broadest coverage: Vibe Island (16 agents)
  • Most comprehensive: AiderDesk (30+ LLMs, extensions, worktrees, vector search)

Observable failure modes

  1. Aider dependency: AiderDesk's "Aider tools" require a Python Aider installation. Users who don't already use Aider face an extra setup step.
  2. Extension API stability: The 30+ lifecycle hook API is young; breaking changes could invalidate user extensions.
  3. Vercel AI SDK dependency: Any breaking change in ai package APIs impacts the core agent runtime.
  4. LanceDB storage growth: Vector indexes for large codebases can consume significant disk space.
  5. Approval gate fatigue: In strict autonomy mode, every file read/write needs approval — productive for sensitive operations, tedious for routine ones.
  6. Windows/Linux parity: Complex native features (worktrees, process spawning) are harder to maintain cross-platform.
04

Workflow

AiderDesk — Workflow

Core development workflow

1. Create Project (point at repository directory)
2. Create Task (feature/bug description)
   → Optional: initialize Git worktree for task isolation
3. Configure context files:
   → Semantic search (LanceDB finds relevant files)
   → Manual pin (add specific files)
   → IDE connector sync (IntelliJ / VS Code auto-adds edited files)
4. Run agent:
   → Choose agent profile (or default)
   → Choose LLM provider + model
   → Submit prompt
5. Agent streams response with tool calls:
   → Tool approval gates fire for shell commands + file operations
   → Approve / deny / modify each action
6. Review diff:
   → Side-by-side or unified diff viewer
   → Edit history: delete bad messages from context
7. Accept changes:
   → Changes applied to worktree
   → Review and merge worktree when satisfied

Advanced task management

Fork task → Create alternative implementation path from any point
Duplicate task → Clone task for parallel exploration
Delete messages → Remove bad AI context from history

Extension lifecycle

Extension hooks fire at:
- onTaskCreated → custom initialization
- onPromptFinished → post-response processing (linting, formatting)
- onToolCalled → intercept/validate tool execution
- onFileAdded → custom file handling
- (30+ more events)

Skills workflow

Agent detects need for domain knowledge
→ Calls skills/activate-skill tool
→ SKILL.md loaded progressively (summary → detail → references)
→ Context enriched without pre-loading all documentation

Artifacts

Artifact Location Purpose
Worktree branch git worktree Task isolation
Memory entries .aider-desk/memory/ Cross-session context
Todo lists In-memory + task state Task tracking
Usage data SQLite Cost/token analytics

Approval gates

  1. Shell command execution — GUI approval required before bash tool runs
  2. File operation — GUI approval required before write/edit operations
  3. Diff review — Human must inspect all proposed changes before apply

Phases

  1. Project setup — Repository configuration, provider selection
  2. Task creation — Feature description, optional worktree
  3. Context assembly — Vector search + manual file selection
  4. Agent execution — Streaming AI with approval gates
  5. Review — Diff inspection, history editing
  6. Merge — Worktree merge back to main branch
06

Memory Context

AiderDesk — Memory & Context

Memory system

AiderDesk provides a MemoryManager with key-value storage per project/task:

// memory tools: store / retrieve / list / delete
// backed by: file-based JSON or SQLite (project-scoped)

The AI agent can call memory/store to persist information, memory/retrieve to recall it, and memory/list to see all keys. This is an explicit memory API — the agent decides what to remember, unlike ccmemory's automatic graph extraction.

Vector embedding context (LanceDB)

AiderDesk uses LanceDB for semantic file search:

  • Repository files are indexed with vector embeddings
  • power/semantic-search tool returns contextually relevant files for any query
  • This eliminates the need for manual context file selection for most tasks

Handlebars prompt templates

The CompactConversationPromptData template handles context compaction — when conversation history grows large, AiderDesk compacts it using a configurable prompt template. This is explicitly documented as ContextCompactionType in the agent config.

Cross-session handoff

The HandoffPromptData template manages context handoff between sessions. The UpdateTaskStateData template persists task state for session restart.

Persistence scope

Data Storage Scope
Memory entries File-based JSON Per-project
Task history SQLite Global
Usage data SQLite Global
Vector index LanceDB Per-project
Session chat SQLite Per-task

Context file management

Three mechanisms for context file selection:

  1. Manual: User explicitly pins files
  2. Semantic search: LanceDB finds relevant files from a query
  3. IDE connector: IntelliJ or VS Code plugin auto-adds currently edited files

Users can also pin documentation URLs as context.

07

Orchestration

AiderDesk — Orchestration

Multi-agent

Yes — AiderDesk supports subagent delegation via the tasks/run-task tool. The top-level agent can spawn sub-tasks with specialized agent profiles. The built-in sub-agents (code-checker, code-reviewer, test-writer, translation-manager) demonstrate the pattern.

Orchestration pattern

Hierarchical — top-level task agent delegates to sub-agents for specialized work, then integrates results. The tasks/search-parent-task tool lets sub-agents query the parent task's context.

Isolation mechanism

Git worktree — each task can optionally run in an isolated Git worktree. The worktrees/ directory in main process manages worktree lifecycle (create, merge, cleanup).

Execution mode

Interactive GUI — streaming AI output with approval gates at each destructive action. Not continuous/daemon.

Multi-model

Yes — AiderDesk supports 30+ LLM providers (OpenAI, Anthropic, Gemini, DeepSeek, Ollama, and more). Different agent profiles can use different providers. Sub-agents can use different models from the parent.

Consensus mechanism

None — single authoritative agent per task (no Raft, quorum, or Byzantine consensus).

Auto-validators

No automatic validators. The approval gate system is human-triggered, not automated.

Extension lifecycle hooks

30+ lifecycle events that extensions can hook into. While not "validators" in the traditional sense, extensions intercepting onToolCalled or onPromptFinished can implement custom validation logic:

// Example extension hook
onToolCalled: async (context, toolName, toolInput) => {
  if (toolName === 'power/bash' && toolInput.command.includes('rm -rf')) {
    throw new Error('Destructive command blocked by extension policy');
  }
}

Approval gates (human-in-loop)

  1. Shell execution: ApprovalManager shows GUI dialog before running bash commands
  2. File operations: GUI approval for file write/edit
  3. Diff review: Full diff visible before changes applied to disk

The AutonomyMode config controls how aggressive the approval requirements are:

  • Strict: approve every tool call
  • Balanced: approve only destructive operations
  • Autonomous: minimal approvals
08

Ui Cli Surface

AiderDesk — UI & CLI Surface

Desktop application (primary surface)

Electron app on Windows, macOS, and Linux.

Key screens:

Screen Function
Projects + Tasks Multi-project workspace with task management
Chat view Streaming AI conversation with tool call rendering
Diff viewer Side-by-side and unified code review before apply
Context panel File selection (manual, semantic search, IDE sync)
Agent profiles Custom system prompts and tool sets per agent
Model selector 30+ provider + model combinations
Worktree manager Git worktree creation, merge, cleanup
Extension gallery Browse and install extensions
Usage dashboard Cost and token analytics
Settings Global and project configuration

Approval gate UI

When the AI calls a tool requiring approval:

  • GUI dialog shows the tool name, inputs, and context
  • User can approve, deny, or provide corrective input
  • History of approvals visible in task log

REST API

AiderDesk exposes a REST API for external integration. Allows triggering tasks, querying history, and managing projects from external scripts or CI/CD pipelines.

MCP server mode

AiderDesk can expose itself as an MCP server:

  • Claude Desktop can connect to AiderDesk's task/agent system
  • Cursor can use AiderDesk's context management and tools

IDE connectors

  • IntelliJ IDEA plugin (hotovo-sk.aider-desk-connector): Auto-adds files currently open in IDE to AiderDesk context
  • VS Code extension (hotovo-sk.aider-desk-connector): Same for VS Code

CLI binary

None for end users. npx @aiderdesk/extensions install is available for extension management.

Distribution

  • GitHub Releases (Windows exe, macOS dmg, Linux AppImage)
  • Docker image
  • Homebrew (mentioned in docs)
  • Scoop (mentioned in docs)

Voice control

Native voice input using "top-tier voice models" for hands-free operation. Provider and model unspecified.

Theming

React 19 + Tailwind CSS with multiple built-in dark and light themes.

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…