Aperant — Summary

Aperant (formerly "Auto Claude") is a cross-platform Electron desktop application that wraps Claude Code to provide a visual kanban board, parallel agent terminals, and a self-validating QA loop for autonomous software development. Users describe a task on the kanban board; Aperant spawns up to 12 parallel agent terminals, each running Claude Code in an isolated git worktree; a built-in QA loop validates results before presenting them for human review. Native features include GitHub/GitLab issue import, Linear sync, AI-powered merge conflict resolution, and a cross-platform installer for Windows/macOS/Linux.

Aperant is the most feature-complete autonomous coding desktop in this batch. Unlike Eigent (CAMEL-AI Python backend) or Agent Deck (Go TUI), Aperant stays firmly in the Claude Code + Electron ecosystem and adds a thin orchestration layer on top of vanilla Claude Code sessions. Compared to claude-flow (closest seed), Aperant provides the kanban/terminal UI claude-flow lacks while reusing standard Claude Code sessions rather than building an MCP toolserver.

Aperant — Overview

Origin

Started as "Auto Claude" by Andre Mikalsen (AndyMik90). Renamed to Aperant; AGPL-3.0 licensed with commercial licensing available. 14,304 stars, 24 contributors (develop branch). Version 2.7.6 stable, 2.8.0-beta in progress as of 2026-05-26.

Philosophy

From the README: "Autonomous multi-agent coding framework that plans, builds, and validates software for you."

The core thesis is that autonomous coding at scale requires three things together: parallelism (up to 12 concurrent agents), workspace isolation (git worktrees per task), and a self-validating QA loop (agents catch issues before human review). The desktop GUI makes this accessible without terminal expertise.

Key Design Decisions

1. Claude Code as agent: Aperant does not build its own LLM agent; it spawns Claude Code instances. Requires "Claude Pro/Max subscription."
2. git worktrees for isolation: Each task gets its own worktree — main branch never touched during agent work.
3. AI-powered merge: Automatic conflict resolution when integrating results back to main.
4. QA loop: "Self-Validating QA" catches issues before human review — agents check their own work.

Security Model

Three-layer: OS Sandbox (bash in isolation), Filesystem Restrictions (operations limited to project directory), Dynamic Command Allowlist (approved commands based on detected project stack).

Aperant — Architecture

Distribution

• Type: Electron desktop application (TypeScript)
• Platforms: Windows (.exe), macOS (arm64 .dmg + x64 .dmg), Linux (.AppImage, .deb, .flatpak)
• Install: Download from GitHub Releases; SHA256 checksums + VirusTotal scan provided

Directory Tree

Aperant/
├── apps/
│   └── desktop/         # Electron desktop application
│       ├── src/         # TypeScript agent layer + React UI
│       └── package.json
├── guides/              # Additional documentation
│   └── linux.md
├── scripts/             # Build utilities
├── .claude/             # Claude Code settings
└── package.json

Required Runtime

• Claude Pro/Max subscription (Claude Code OAuth)
• Claude Code CLI (npm install -g @anthropic-ai/claude-code)
• Git repository (project must be a git repo)
• No Node.js required for end users (bundled in Electron)

Config Files

• .claude/ (reuses standard Claude Code settings)
• Memory.md (agent memory across sessions)
• CLAUDE.md (custom instructions)

Target AI Tools

Claude Code (Claude Pro/Max required). Not model-agnostic.

Tech Stack

• Electron (TypeScript)
• React + TypeScript (UI layer)
• Claude Code SDK (agent execution)
• Git worktrees (isolation layer)
• GitHub API + Linear API (integrations)

Aperant — Components

Desktop UI Views

Core Features

Security Components

Aperant — Uniqueness & Positioning

differs_from_seeds

Aperant is the most direct visual counterpart to claude-flow: both manage parallel Claude Code agents in git worktrees with hierarchical coordination. The architectural delta is that Aperant wraps this in an Electron kanban UI with self-validating QA, GitHub/Linear integrations, and AI-powered merge conflict resolution — all without adding a single MCP tool or custom subagent definition. Claude-flow has 305 MCP tools, SPARC phases, and a vector database; Aperant has zero of those but has a polished desktop application. Among the 11 seeds, Aperant is also closer to kiro's "desktop-first" posture than any other, but kiro is a VS Code fork IDE while Aperant is purely a task/agent management surface built on top of standard Claude Code. The three-layer security model (OS sandbox + filesystem restriction + dynamic command allowlist) is not found in any seed.

Positioning

• Only framework in batch with hard-coded 12-agent concurrency limit (explicitly documented).
• Only framework with native GitHub/GitLab MR creation + Linear sync in a desktop GUI.
• AGPL-3.0 license with commercial licensing for closed-source use cases.
• Requires Claude Pro/Max — not usable with free tier or alternative LLMs.

Observable Failure Modes

1. Claude Pro/Max lock-in: Requires paid subscription; free users cannot use Aperant at all.
2. Worktree proliferation: 12 parallel worktrees on a large repo can consume significant disk space and slow git operations.
3. QA loop quality depends on model: Self-validating QA is a second Claude Code pass — it can miss issues a real test suite would catch.
4. No unit test enforcement: No TDD gate; QA loop is LLM-based review, not automated test runner.
5. Single-model: Cannot use cheaper models for non-critical tasks, raising API costs.