Skip to content
/
Tier B A12 UI passthrough

Paperclip

paperclip · paperclipai/paperclip · ★ 68k · last commit 2026-05-26

Primitive shape 41 total
Commands 22 Skills 8 Subagents 11
00

Summary

Paperclip — Summary

Paperclip is an open-source AI company control plane (67,777 stars, MIT, TypeScript) that positions itself as "the company" to agents' "employee" role: "If OpenClaw is an employee, Paperclip is the company." It is not an agent framework or workflow builder — it provides org charts, budgets, governance, heartbeats, ticket systems, and multi-company isolation for running teams of heterogeneous agents. The CLI (paperclipai binary, commander.js) installs via npx paperclipai onboard and starts a Node.js Express server with an embedded PostgreSQL database (embedded-postgres). The UI is a React+Vite board served by the API server. Agents are pluggable via adapter packages: Claude Code, Codex, Cursor (local + cloud), Gemini, Grok, OpenClaw, OpenCode, Pi (11 adapters). Each agent has a role, title, org chart position, reporting line, and monthly budget. A heartbeat execution engine wakes agents on schedules; each run produces an atomic execution with structured logs, cost events, and audit trails. Git worktrees isolate per-task workspaces. Governance features include board-level approval gates, execution policies, agent pause/resume/terminate, and config rollback. Multi-company support gives complete data isolation per company in one deployment.

01

Overview

Paperclip — Overview

Origin

Paperclip is from the paperclipai organization. 67,777 stars, ~30 contributors. MIT license. TypeScript (Node.js + React). Active as of 2026-05-26. Latest release: v2026.525.0.

Philosophy

README: "Open-source orchestration for zero-human companies. If OpenClaw is an employee, Paperclip is the company."

Key principles:

  • Company, not chatbot: Agents have jobs, not chat windows
  • Org chart as primitive: Agents have roles, titles, reporting lines, and budgets
  • Goal ancestry: Every task traces back to the company mission — agents know what and why
  • Heartbeat execution: Agents wake on schedule, check work, and act without manual kick-offs
  • Governance first: Board approval gates, budget hard stops, full audit log — human stays in control
  • Bring your own agent: Any runtime that can receive a heartbeat is hireable (Claude Code, Codex, Cursor, Gemini, Grok, bash, HTTP bots)

Target User

README: "If you have 20 simultaneous Claude Code terminals open and lose track of what everyone is doing." Paperclip is explicitly for teams of agents, not single-agent use. It provides the management layer that organizations need when scaling beyond 5-10 agents.

Anti-Patterns Paperclip Rejects

  • It is not a chatbot
  • It is not an agent framework (doesn't tell you how to build agents)
  • It is not a workflow builder (no drag-and-drop pipelines)
  • It is not a prompt manager (agents bring their own prompts)
  • It is not a single-agent tool
  • It is not a code review tool (manages work, not PRs)

Key Systems

  • Identity & Access: Board users, agent API keys, short-lived run JWTs, company memberships
  • Work & Task System: Issues with goal ancestry, atomic checkout, blocker dependencies
  • Heartbeat Engine: DB-backed wakeup queue, budget checks, workspace resolution, adapter invocation
  • Governance & Approvals: Board approval workflows, execution policies, rollback
  • Budget & Cost Control: Per-agent/project/goal spending with hard stops
  • Routines & Schedules: Cron, webhook, API-triggered recurring tasks
  • Plugins: Out-of-process workers with host service access
  • Company Portability: Export/import entire orgs with secret scrubbing
02

Architecture

Paperclip — Architecture

Distribution

  • CLI: paperclipai binary (npm, commander.js); npx paperclipai onboard
  • Server: Node.js Express REST API (server/)
  • UI: React + Vite SPA (ui/), served by API server at same port
  • Database: Embedded PostgreSQL (embedded-postgres@18.1.0-beta.16) — no external DB required for dev/local
  • Monorepo: pnpm workspace

Repo Structure

paperclip/
├── cli/                    # paperclipai CLI binary (commander.js)
│   └── src/
│       ├── commands/       # onboard, configure, doctor, run, heartbeat-run, worktree, ...
│       │   └── client/     # agent, issue, company, approval, activity, ...
│       └── adapters/       # CLI-side adapter bootstrapping
├── server/                 # Express API + orchestration services
│   └── src/
│       ├── http/           # REST routes
│       ├── auth/           # Identity, JWT, board-claim
│       ├── lib/            # Heartbeat engine, task system, governance
│       └── adapters/       # Server-side adapter invocation
├── ui/                     # React + Vite board UI (@paperclipai/ui)
│   └── src/
│       └── pages/          # 80+ page components (Dashboard, OrgChart, Issues, Goals, ...)
├── packages/
│   ├── db/                 # Drizzle ORM schema + migrations (PostgreSQL)
│   ├── shared/             # Types, constants, validators, API path constants
│   ├── adapters/           # Agent adapter implementations (11 adapters)
│   │   ├── claude-local/   # Claude Code adapter
│   │   ├── codex-local/    # Codex adapter
│   │   ├── cursor-local/   # Cursor local adapter
│   │   ├── cursor-cloud/   # Cursor cloud adapter
│   │   ├── gemini-local/   # Gemini adapter
│   │   ├── grok-local/     # Grok adapter
│   │   ├── openclaw-gateway/ # OpenClaw HTTP gateway adapter
│   │   ├── opencode-local/ # OpenCode adapter
│   │   ├── acpx-local/     # ACPX adapter
│   │   ├── pi-local/       # Pi adapter
│   │   └── adapter-utils/  # Shared adapter utilities
│   ├── mcp-server/         # MCP server integration
│   └── plugins/            # Plugin system
├── skills/                 # Built-in skills (8 skill packages)
├── doc/                    # Spec, product, architecture docs
│   ├── SPEC.md             # Long-horizon product spec
│   ├── SPEC-implementation.md # Concrete V1 build contract
│   ├── GOAL.md
│   └── PRODUCT.md
├── AGENTS.md               # Dev + AI contributor guidelines
└── .claude/                # Claude config

Runtime

CLI (paperclipai)
    → Embedded PostgreSQL (startup)
    → Express API server (localhost:3100)
    → React+Vite UI (served by API server)
         ↕ REST API
    → Heartbeat Engine
         → Adapter invocation (claude-local, codex-local, cursor-*, gemini, grok, ...)
         → Git worktree (per-task isolation)
         → Secret injection
         → Skill loading
         → Budget check (hard stop if exceeded)
         → Audit log write

Deploy Modes

  • Trusted local (default): loopback, no auth required; fastest first run
  • LAN: --bind lan; authenticated mode for local network access
  • Tailnet: --bind tailnet; Tailscale access for mobile monitoring on the go
  • Production: external PostgreSQL, deploy Node.js server anywhere (Vercel, bare server)
03

Components

Paperclip — Components

CLI (paperclipai)

Command Purpose
onboard First-run setup; starts server + embedded DB
configure Edit configuration
doctor Health check
env / env-lab Environment management
run Execute an agent run directly
heartbeat-run Trigger heartbeat execution
worktree Manage git worktrees
auth-bootstrap-ceo Bootstrap CEO agent auth
db-backup Backup database
allowed-hostname Manage allowed hostnames
client subcommands
agent Agent CRUD
issue Task/issue management
company Company management
approval Approval workflows
activity Activity log
dashboard Dashboard data
routines Routine/schedule management
context Context management
feedback Feedback submission
secrets Secret management
cloud Cloud upstream sync
plugin Plugin management

Agent Adapters (11)

Adapter Runtime
adapter-claude-local Claude Code (local)
adapter-codex-local Codex (local)
adapter-cursor-local Cursor (local)
adapter-cursor-cloud Cursor (cloud)
adapter-gemini-local Gemini (local)
adapter-grok-local Grok (local)
adapter-openclaw-gateway OpenClaw (HTTP gateway)
adapter-opencode-local OpenCode (local)
adapter-acpx-local ACPX (local)
adapter-pi-local Pi (local)
adapter-utils Shared utilities

UI Pages (80+)

Key pages in the React+Vite board:

  • Dashboard / DashboardLive — real-time agent activity
  • OrgChart — visual org chart with reporting lines
  • Issues / IssueDetail — task/ticket management with chat threads
  • Goals / GoalDetail — goal hierarchy (company → project → goal → issue)
  • Agents / AgentDetail / NewAgent — agent management
  • Approvals / ApprovalDetail — governance approval queue
  • Projects / ProjectDetail — project management
  • Routines / RoutineDetail — recurring task schedules
  • Costs — cost/budget tracking by agent, project, goal
  • Activity — audit log viewer
  • Secrets — secret management
  • Companies — multi-company management
  • CompanySettings / InstanceSettings — configuration
  • Workspaces / ExecutionWorkspaceDetail — workspace management
  • CompanySkills — skill configuration
  • Inbox / MyIssues — personal task view
  • Search — global search
  • CloudUpstream — cloud sync management

Skills (Built-in, 8)

Skill Purpose
paperclip Core Paperclip workflow skills
paperclip-dev Development skills
paperclip-create-agent Agent creation skills
paperclip-create-plugin Plugin creation skills
paperclip-converting-plans-to-tasks Planning → tasks
para-memory-files PARA-method memory file management
diagnose-why-work-stopped Debugging stalled work
terminal-bench-loop Terminal benchmarking

Packages

  • @paperclipai/db — Drizzle ORM schema + migrations
  • @paperclipai/shared — types, constants, validators, API paths
  • @paperclipai/server — Express server (importable as library)
  • @paperclipai/mcp-server — MCP server integration
  • @paperclipai/plugins — Plugin system
05

Prompts

Paperclip — Prompts & Instructions

Paperclip's Stance: No Prompt Management

Paperclip explicitly states: "Not a prompt manager. Agents bring their own prompts, models, and runtimes. Paperclip manages the organization they work in."

The platform does not provide a system prompt editor, prompt templates, or prompt tuning tools. Each agent adapter is responsible for constructing and managing prompts internally.

Context Injection (Not Prompts)

What Paperclip injects into agent execution context:

  • Task context: issue title, description, comments, attachments
  • Goal ancestry: company → project → goal → issue chain (agents know "why")
  • Previous conversation: prior run transcripts for the same issue
  • Secrets: scoped secrets for the current run (injected by heartbeat engine, not in prompts)
  • Skills: skill text loaded at runtime into agent context
  • Workspace path: resolved git worktree path

This context is structured and delivered by the heartbeat engine — it is not a prompt template, it is a data delivery mechanism.

Skills as Runtime Context

The skills/ directory contains 8 built-in skill packages. Skills are text documents that describe Paperclip-specific workflows and conventions. At runtime, the heartbeat engine injects relevant skills into the agent's context before invocation.

Key skills:

  • paperclip — how to use Paperclip (create issues, report work, request approvals)
  • paperclip-converting-plans-to-tasks — how to decompose plans into trackable issues
  • diagnose-why-work-stopped — debugging stalled executions
  • para-memory-files — PARA method for organizing memory files

AGENTS.md / .claude/

The repo ships:

  • AGENTS.md — guidelines for human and AI contributors to the Paperclip codebase
  • .claude/ — Claude Code configuration for developing Paperclip itself

These are for AI-assisted development of Paperclip, not runtime agent behavior.

Agent System Prompts (Adapter-Defined)

Each adapter package (adapter-claude-local, adapter-codex-local, etc.) defines how it initializes its agent runtime. Claude Code adapter starts CC with a structured initial message; Codex adapter similarly. The prompt/instruction content is entirely delegated to the adapter and the underlying agent runtime.

Goal Ancestry as Implicit Prompt Context

The most important "prompt engineering" in Paperclip is the goal ancestry injection. Every issue carries: company mission → project goal → task goal → issue description. This means agents receive structured context about why a task exists without needing prompt-level instructions. Paperclip's thesis: context architecture beats prompt engineering.

09

Uniqueness

Paperclip — Uniqueness

Defining Characteristic

Paperclip's core claim — "If OpenClaw is an employee, Paperclip is the company" — is a product positioning statement that describes a genuinely distinct architectural layer. While every other framework in this batch focuses on the agent execution level (how agents run, communicate, and collaborate), Paperclip operates at the organizational level: org charts, budgets, governance, heartbeat schedules, multi-company isolation, and board-level approval gates. This is not a multi-agent orchestrator — it is a corporate management system where the "employees" happen to be AI agents.

Anti-Chat UI as Philosophy

Paperclip deliberately rejects chat as its primary UI metaphor. The IssueDetail page includes conversation threads, but the main UI is a task management board. This is the strongest UI philosophy statement in the entire batch: agents should have jobs tracked in tickets, not conversations in chat windows. No other framework in the batch or the seed list makes this architectural bet.

Budget Enforcement as First-Class Primitive

Monthly per-agent/per-project/per-goal/per-model budgets with atomic checkout and hard stops are a production engineering feature not present in any other framework in the batch. Paperclip's argument: "runaway loops waste hundreds of dollars" is a real problem at scale, and solving it requires budget enforcement at the orchestration layer, not ad-hoc at the agent level.

Org Chart as Orchestration

The org chart model (roles, titles, reporting lines, manager-agent assignments) is unique in the corpus. Other hierarchical frameworks (hiclaw, agent-deck) have a flat Manager-Workers relationship. Paperclip's org chart supports arbitrary depth and structure — CEO → VPs → managers → individual contributors — mirroring real organizational design.

Company Portability / Clipmart

The upcoming "Clipmart" feature (export/import entire company templates with one click) represents a marketplace of companies as composable units — not tools, not agents, but entire organizational configurations. No framework in the batch has a concept at this level.

Governance with Rollback

Config change versioning with rollback, execution policies with approval stages, and an immutable audit log are enterprise compliance features. The framing "you're the board" positions human oversight as a governance mechanism, not a debugging fallback.

Tradeoffs

The task-management UI metaphor requires more upfront setup than a chat UI — agents must be defined in the org chart, goals must be structured, issues must be created. This is intentional but creates friction for quick ad-hoc tasks. The embedded PostgreSQL default is convenient for dev but the codebase must be configured for production PostgreSQL separately. The 11 adapter packages cover major runtimes but adding a new agent type requires writing an adapter implementation. The "company" metaphor may not fit all use cases — Paperclip is explicitly not for single-agent or small-scale use.

04

Workflow

Paperclip — Workflow

Initial Setup

  1. npx paperclipai onboard --yes — installs server + embedded PostgreSQL; opens UI at localhost:3100
  2. Human creates a Company (or imports a company template from Clipmart)
  3. Human defines company mission/goals
  4. Human "hires" agents: assigns role, title, adapter (Claude Code / Codex / Cursor / etc.), model, budget
  5. Human configures org chart: reporting lines, manager assignments

Goal Hierarchy Creation

  1. Human creates top-level Company Goal (e.g., "Build the #1 AI note-taking app to $1M MRR")
  2. Human or CEO agent decomposes into Projects and sub-goals
  3. Sub-goals become Issues (tasks) in the ticket system
  4. Every issue carries full goal ancestry ("company → project → goal → issue") so agents always know why

Task Assignment & Execution

  1. Issue is assigned to an agent (manually or by manager agent)
  2. Agent's heartbeat schedule triggers (or manual paperclipai heartbeat-run)
  3. Heartbeat engine: checks budget → resolves workspace → injects secrets → loads skills → invokes adapter
  4. Adapter starts the agent runtime (e.g., Claude Code) in a git worktree
  5. Agent receives task context (issue title, description, goal ancestry, previous conversation)
  6. Agent executes; produces structured logs, cost events, session state
  7. Results written as issue comments + work products
  8. Run closes; budget updated; audit log appended

Governance / Approval Gate

If a task requires board approval:

  1. Agent proposes action; creates approval request
  2. Approval appears in the Approvals queue in the UI
  3. Human reviews and approves/rejects
  4. Approved: execution continues; rejected: agent receives rejection with feedback
  5. All approval decisions recorded in audit log

Routine Execution (Recurring Tasks)

  1. Human creates Routine with cron/webhook/API trigger + agent assignment
  2. Paperclip creates a new Issue each time the trigger fires
  3. Assigned agent wakes via heartbeat and processes the issue
  4. Results posted; next trigger scheduled

Multi-Agent Delegation

  1. Manager agent receives high-level goal from human
  2. Manager creates sub-issues and assigns to specialist agents
  3. Specialist agents execute in parallel (each with own heartbeat + workspace)
  4. Manager agent reviews completed sub-issues and synthesizes
  5. Final result posted to parent issue

Mobile Monitoring

  1. Human accesses Paperclip UI from mobile browser (responsive design)
  2. Views live dashboard, approves/rejects requests, monitors costs
  3. Tailscale binding (--bind tailnet) for secure mobile access on the go
06

Memory Context

Paperclip — Memory & Context

Primary Memory: PostgreSQL

@paperclipai/db (Drizzle ORM) with PostgreSQL (embedded in dev; external in prod) stores all durable state:

  • Companies, projects, goals, issues, agents, routines
  • Issue conversations (comments, work products, attachments)
  • Run logs, cost events, audit trails
  • Agent configs, budgets, permissions
  • Secrets (encrypted)
  • Session state per heartbeat run

Full persistence across sessions. No data loss on restart.

Persistent Agent Sessions

The heartbeat engine stores session state (e.g., Claude Code session ID) from each run. On the next heartbeat, the agent can resume the same conversation context rather than starting fresh. This is "persistent agent state" — one of Paperclip's claimed differentiators vs. tools that restart from scratch on each invocation.

Issue Context as Memory

Each issue accumulates its full conversation history: comments, work products, agent tool call traces, approval decisions. When an agent is woken on the next heartbeat, it receives the full prior conversation for that issue. This is the primary context continuity mechanism — not a vector store, but structured conversation threads.

Goal Ancestry as Structural Memory

Every issue carries a denormalized "goal ancestry" chain (company → project → goal → issue). This persists in the database and is delivered to agents on every invocation. The agent always has the "why" context without needing to look it up.

Skills as Runtime-Injected Context

The 8 built-in skills and any installed custom skills are text files that the heartbeat engine loads and injects before invoking the adapter. Skills encode Paperclip-specific workflows — how to create issues, how to request approvals, how to report work completion.

PARA Memory Files Skill

The para-memory-files skill teaches agents to maintain PARA-method memory files (Projects, Areas, Resources, Archive) in their workspace. This is an agent-managed file-based memory layer on top of the structured PostgreSQL memory.

Worktree as Scoped Working Memory

Each task execution gets an isolated git worktree. The agent reads/writes files in this worktree during its run. Work products are attached to the issue on completion. Worktrees persist across heartbeats for the same issue — the agent's file system state is preserved.

Cost & Audit as Memory

All token consumption and cost events are recorded per agent/project/goal/issue/provider/model. Budget policies read this history to enforce hard stops. The audit log provides an immutable record of every mutating action for compliance/replay.

No Vector Store (Core)

Paperclip's core memory architecture is relational PostgreSQL, not vector search. The @paperclipai/mcp-server package suggests MCP-based tool access that could include vector search externally, but the platform itself does not bundle a vector database.

07

Orchestration

Paperclip — Orchestration

Org Chart as Orchestration Structure

Paperclip models orchestration as a corporate org chart. Agents have:

  • Title and role (CEO, CTO, Engineer, Designer, Marketer, etc.)
  • Reporting lines (manager → reports)
  • Permissions scoped to their role
  • Budget (monthly spend limit; hard stop when exceeded)

Orchestration follows org chart reporting lines: manager agents create sub-issues and assign them to reports; reports complete work and post results; manager reviews and escalates or synthesizes.

Heartbeat Execution Engine

The central orchestration primitive in Paperclip is the heartbeat:

Trigger (cron / webhook / API / manual)
    → DB-backed wakeup queue (coalescing — no duplicate runs)
    → Budget check (hard stop if limit exceeded)
    → Workspace resolution (git worktree)
    → Secret injection
    → Skill loading
    → Adapter invocation (claude-local / codex-local / cursor / gemini / grok / ...)
    → Structured execution log
    → Cost event recording
    → Session state save
    → Audit trail append
    → Recovery for orphaned runs (automatic)

Atomic Task Checkout

Issue assignment is atomic with an execution lock. No two heartbeats can check out the same issue simultaneously — no double-work. Budget enforcement is also atomic with checkout.

Governance Layer

Paperclip's governance system treats the human as the "board":

Agent proposes action requiring approval
    → Approval request created (type: execution policy / strategy / config change)
    → Human receives notification (dashboard / UI)
    → Human approves or rejects with feedback
    → Approved: execution continues
    → Rejected: agent receives structured rejection
    → All decisions recorded in immutable audit log

Board approval workflows, execution policies with review/approval stages, and config change versioning with rollback are built-in.

Multi-Company Isolation

One Paperclip deployment can host multiple companies. Every database entity is company-scoped — complete data isolation. This enables a single operator to run a portfolio of AI companies from one control plane.

Plugin System

Plugins run as out-of-process workers with capability-gated access to host services. They can expose tools to agents, contribute UI, and schedule background jobs. This is the primary extension point without forking the codebase.

No Fixed Manager Agent

Unlike hiclaw (fixed Manager role) or aperant (planning agent), Paperclip's orchestration structure is defined by the org chart, not by a single designated orchestrator. The CEO agent at the top of the org chart acts as the de facto coordinator, but any agent at any level can delegate to its reports via issue assignment.

Concurrent Parallel Execution

Multiple agents execute independently on their assigned issues. Each has its own heartbeat schedule and execution workspace. Budget enforcement and worktree isolation prevent interference. The org chart reporting structure provides logical coordination; the technical execution is fully parallel.

08

Ui Cli Surface

Paperclip — UI & CLI Surface

Web UI (Primary Interface)

  • URL: http://localhost:3100 (served by API server; same port)
  • Technology: React + Vite + @radix-ui/react-slot + Tailwind CSS + @assistant-ui/react + @mdxeditor/editor + @dnd-kit/* + @lexical/*
  • Architecture: SPA served by Express server in dev middleware mode; static build served in production
  • Storybook for component development

The UI is a full task management board — intentionally designed to feel like a project management tool, not an AI chat interface:

Key pages (80+):

Category Pages
Work Issues, IssueDetail, MyIssues, Inbox, Goals, GoalDetail, Projects, ProjectDetail
Org OrgChart, Agents, AgentDetail, NewAgent
Dashboard Dashboard, DashboardLive (real-time stream)
Governance Approvals, ApprovalDetail
Automation Routines, RoutineDetail
Costs Costs (by agent/project/goal/model)
Activity Activity (immutable audit log)
Infrastructure Workspaces, ExecutionWorkspaceDetail, ProjectWorkspaceDetail
Config Secrets, CompanySettings, InstanceSettings, PluginManager, AdapterManager
Multi-company Companies, CompanyExport, CompanyImport
Cloud CloudUpstream
Other Search, Auth, UserProfile, ProfileSettings

Design philosophy: agents have jobs, not chat windows. The IssueDetail page shows the full conversation thread for a task (agent messages + tool call traces), but the primary interface is task management, not chat.

CLI (paperclipai)

Binary: paperclipai v0.3.1. Built with TypeScript + esbuild + commander.js.

Infrastructure commands (direct):

Command Purpose
onboard [--yes] [--bind <preset>] First-run setup; starts server
configure Edit configuration interactively
doctor Run health checks
env / env-lab Environment management
run Execute agent run directly
heartbeat-run Trigger heartbeat execution
worktree Manage git worktrees
auth-bootstrap-ceo Bootstrap CEO agent authentication
db-backup Backup PostgreSQL database
allowed-hostname Manage allowed hostname whitelist
routines Manage routines

Client commands (connect to running server):

Command Purpose
agent Agent CRUD
issue Task/issue management
company Company management
approval Approval workflows
activity Activity log
dashboard Dashboard data
context Context management
feedback Feedback
secrets Secret management
cloud Cloud upstream sync
plugin Plugin management
zip Export/compress data

Quickstart

npx paperclipai onboard --yes
# Server + embedded PostgreSQL start at http://localhost:3100
# UI accessible in browser immediately

Mobile-Ready Web UI

The React UI is responsive. Human can monitor org charts, approve requests, and review costs from a mobile browser. Tailscale binding (--bind tailnet) enables secure remote access without exposing the server publicly.

Comparison to Batch Peers

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

Paperclip is the only framework that deliberately avoids chat as the primary UI metaphor. The board-style task manager UI is a product statement: agents have jobs, not conversations.

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…