Introduction

Agenties is a desktop orchestration app for running persistent project teams of AI coding agents. Each project has an orchestrator that delegates to builders, reviewers, scouts, and coordinators through a shared mailbox, tracks goals and issues on disk, and keeps durable project memory locally under .agenties/. Optional integrations — Obsidian, NotebookLM — add human-readable knowledge layers, but they are not required and are not the source of operational truth.

What is Agenties?

Most AI coding tools give you a single agent that does one task at a time. Agenties is different: it models software development the way human teams work. There is one Intelligent Manager (the orchestrator) per project that never writes code itself. Its only job is to read the project state, decide what needs to happen, and delegate to specialists via the spawn_agent MCP tool.

Sub-agents are ephemeral Claude Code processes — they start, do their work, write results to the mailbox and the shared vault, then exit. The orchestrator wakes up whenever a sub-agent finishes, reads the new state, and decides what to do next. This loop continues until the objective is met.

Key capabilities

Persistent orchestrator per project

Each project has its own orchestrator with a Claude session ID that resumes across turns. Between turns it is completely dormant — zero compute, zero cost. It re-activates when you send a message, when a sub-agent posts a task-done message, or on a heartbeat schedule.

Specialised agent team

Your team members are configured with a name, role, model (Opus 4.7, Sonnet 4.6, Haiku 4.5), effort level, and base instructions. The orchestrator hires from this roster when it spawns agents. Each team member accumulates experience (XP) and levels up from Rookie to Expert as they complete more tasks.

Multi-PC sync

Issues, team configuration, heartbeats, and routines are synced in real-time across all your machines through Agenties cloud sync. A project channel delivers inline data patches so concurrent writes are safe.

Voice chat

Talk to your orchestrator using your microphone. Agenties supports Web Speech API, browser speech synthesis, Edge TTS neural voices, and on-device Whisper (faster-whisper) for fully private, offline transcription.

Durable project memory

Operational memory — issues, goals, sessions, shared state, continuity journal, and agent reports — is written to .agenties/ on disk and survives restarts, new sessions, and long-running projects. Optionally, agents can export summaries, decisions, and research notes to an Obsidian vault or NotebookLM for human-readable knowledge recall. These integrations are additive; .agenties/ is the canonical source of truth.

Heartbeats

Schedule recurring agent spawns using cron expressions. Heartbeats can run in self-improvement mode — the agent reads your recent session history and writes new slash command skills to ~/.claude/commands/, continuously improving the team's capabilities.

How it works

Here is the end-to-end flow for a typical development task:

You describe a goal

You type (or speak) a message to the orchestrator: "Implement the new user settings page with avatar upload."

Orchestrator plans

The orchestrator reads shared state, open issues, and recent decisions from the vault, then decides to spawn a scout to research the codebase and a builder to implement the feature.

Agents execute concurrently

Claude Code processes start in parallel. The scout reads the codebase and writes findings to the vault. The builder implements the feature, runs tests, and opens a pull request.

Agents report back

When each agent finishes, it posts a task-done message to the mailbox. The orchestrator auto-wakes, reads the results, and decides whether to spawn a reviewer or close the task.

Reviewer verifies

A reviewer agent reads the diff, checks against the requirements, and posts a review-result message. The orchestrator either approves or asks the builder to fix issues.

Done

The orchestrator marks the issue as done, updates shared state, and enters the session wrapup — saving a summary to the vault for future reference.

Architecture overview

Architecture

Agenties Desktop (Tauri v2)
├── Renderer (Next.js / React)
│   ├── Chat UI → sends messages to orchestrator
│   ├── Agent monitor → live status of running agents
│   ├── Issue tracker → open work items
│   ├── Team manager → hire / configure agents
│   └── Settings → models, voice, heartbeats, permissions
│
├── Main process (Rust + Node sidecar)
│   ├── IPC HTTP server (localhost) — bridges renderer ↔ backend
│   ├── Claude Code spawner — starts/stops agent processes
│   ├── MCP server — exposes tools to all Claude sessions
│   ├── Mailbox broker — routes messages between agents
│   └── File watcher — detects .agenties/ state changes
│
├── State files (.agenties/)
│   ├── shared/state.json — current phase, objectives, active agents
│   ├── team.json — team roster with XP
│   ├── issues.json — issue tracker
│   ├── config.json — heartbeats, routines, permissions
│   └── mailbox.jsonl — persistent message log
│
└── Obsidian vault (~/your-vault/, optional integration)
    ├── CONTEXT.md — project description
    ├── decisions.md — architectural decisions log
    ├── sessions/ — per-day session summaries
    └── research/ — scout findings

Design philosophy

Agenties is built on three core beliefs:

Orchestrators, not assistants

The orchestrator is a manager, not a do-er. It should never write code directly — only decide who should write it.

Specialisation beats generalism

A focused builder with the right context outperforms a general agent given the same prompt.

Memory must outlast sessions

Any knowledge that lives only in a context window is knowledge that will be lost. Agenties persists project memory in .agenties/ on disk. Obsidian and NotebookLM are optional human-readable layers on top.

Tip:New to Agenties? The best way to understand it is to follow the quickstart and watch the orchestrator spawn its first agent.

Next →Installation