As promised.
Jetpack is a decentralized multi-agent swarm that coordinates AI agents to build software together—autonomously, safely, at scale. Agents coordinate through data, not control flows.
Made for modern product teams
What is Jetpack?
Jetpack is a decentralized multi-agent swarm orchestration system that coordinates AI agents to work together on large-scale software development.
Built as an 8-package monorepo with a durable Turso cloud database, Jetpack uses advisory file reservations, graph-based task prioritization, and 3-layer semantic memory—creating a crash-resilient environment where agents autonomously claim tasks, share knowledge, and build software at scale.
Monorepo Architecture
Jetpack is built as an 8-package monorepo with a durable DataLayer, decentralized SwarmCoordinator, and model-agnostic agent execution.
Task Queue — Tasks
Persistent structured memory
Replaces messy markdown with a dependency-aware graph. Hierarchical IDs (bd-a3f8.1.1) enable atomic claiming for long-horizon tasks.
Agent Mail — Coordination
Advisory reservations & threading
Advisory file reservations, message threading, and intent broadcasting. Agents announce what files they'll touch before starting—conflicts are data, not errors.
Memory System — Memory Layers
Episodic · Working · Procedural
3-layer memory system with vector embeddings. Episodic memory persists across sessions, working memory has TTL, and procedural memory captures learned patterns.
SwarmCoordinator — Orchestration
Claim strategies & graph prioritization
Model-agnostic agent harness with 5 claim strategies including graph-prioritized (critical path + fan-out + depth). Manages agent lifecycle, health, and recovery.
Component Overview
| Component | Purpose | Storage |
|---|---|---|
| DataLayer | Durable persistence interface (Turso/SQLite) | Turso cloud / .jetpack/jetpack.db |
| Task Queue | Hierarchical task queue with dependency tracking | DataLayer |
| Agent Mail | Advisory reservations, threading & intent broadcasting | DataLayer |
| Memory System | 3-layer semantic memory (Episodic, Working, Procedural) | DataLayer |
| SwarmCoordinator | Agent lifecycle, work distribution & claim strategies | In-memory |
| AgentHarness | Model-agnostic agent execution wrapper | In-memory |
Key Features
Everything you need to orchestrate a swarm of AI agents for software development at scale.
Swarm Intelligence
5 claim strategies including graph-prioritized with critical path analysis
- Skill-based task assignment with best-fit (default), round-robin, and load-balanced strategies
- TaskGraph analysis: critical path, fan-out (dependent count), and depth scoring
- Intent broadcasting — agents announce files they'll touch before starting
Durable State
Turso cloud database as the single source of truth
- 3-layer memory system: Episodic (permanent), Working (TTL), Procedural (learned patterns)
- Agents coordinate through data, not control flows — crash-resilient by design
- Embedded replicas with offline sync and vector search
Safe Coordination
Advisory file reservations — conflicts are data, not errors
- Multiple agents can reserve the same file; conflicts surface as information
- Task dependency DAG ensures correct execution order
- Pre-commit Git hook enforcement via jetpack hook install
Visual Oversight
Real-time dashboard with task graph and agent monitoring
- Kanban board with drag-and-drop task management
- Agent health monitoring with heartbeat tracking
- Quality metrics and regression detection
Model-Agnostic Agents
AgentHarness wraps any LLM — Claude Code, Codex, or custom models
- Skill-based registration and matching (typescript, react, testing, etc.)
- Session isolation via session_id for clean agent lifecycle
- Automatic recovery of stuck tasks from stale agents
Interactive Demos
See It In Action
Explore how Jetpack's core systems work together — from task orchestration to agent coordination and semantic memory.
Layered orchestration
for autonomous coding agents.
A unified architecture coordinating multiple AI agents through task queues, messaging, and semantic memory—enabling long-horizon tasks without losing context.
Persistent structured tasks.
Hierarchical task queue with dependency tracking. TaskGraph provides critical path, fan-out, and depth analysis for smart prioritization.
Coordination layer.
Advisory file reservations, message threading, and intent broadcasting. Agents coordinate through data — conflicts are information, not errors.
Vector-backed semantic memory.
Vector embeddings for semantic search. Agents retrieve relevant context from past work without losing institutional knowledge.
Parallel execution.
1-N worker agents via model-agnostic AgentHarness. Each claims tasks atomically, executes independently, and reports back through Agent Mail.
Persistent Task Queue
_
bd-a3f8Auth Systembd-a3f8.1JWT Setupbd-a3f8.1.1Token Generationbd-a3f8.1.2Validation Logicbd-a3f8.2OAuth Flowbd-a3f8.2.1Google Authbd-a3f8.2.1.1Callback Handlerbd-a3f8.2.1.2Profile Syncbd-a3f8.3Session Managementbd-a3f8.3.1Redis Storebd-a3f8.3.2Expiry Logicbd-a3f8Epicbd-a3f8.1Taskbd-a3f8.1.1Sub-taskbd-a3f8.1.1.1LeafHierarchical task trees with parent-child relationships and dependency tracking.
Race-free task claiming ensures no duplicate work across parallel agents.
Tasks survive restarts—agents resume exactly where they left off.
Coordination Layer for Coding Agents
_
Memory System
_
Past decisions and task history stored as high-dimensional vectors in the memories table.
Active project context and semantic knowledge clustered for fast retrieval.
Learned code patterns and styles—agents query by meaning, not keywords.
Autonomous Task Worker (AgentHarness)
_
SwarmCoordinator subscribes to Agent Mail, starts heartbeat every 30s, begins work loop.
Get ready tasks, filter by skills, sort by priority, claim highest match.
Retrieve memory context, spawn AgentHarness with any LLM, capture output.
Store learnings in Memory System, publish completion via Agent Mail.
Getting Started
Quick Start
Get up and running in under 5 minutes.
git clone https://github.com/agent-jetpack/jetpack-cloud.git && cd jetpack-cloud && pnpm install && pnpm buildcd /your/project && jetpack initjetpack startWhat happens next:
CLI reference, code examples, use cases, and API documentation
What's Next
The future accelerates. Here's what we're building.
Completed
Phase 0: Foundation
14 critical bug fixes — session isolation, leaf-only claiming, recovery, PID tracking
Phase 1: Agent Mail Core
Advisory file reservations, message threading, intent broadcasting, stale cleanup
Phase 2: Smart Coordination
TaskGraph with critical path, fan-out (dependent count), depth scoring, graph-prioritized strategy
Upcoming
Procedural Learning
Pattern extraction from completed tasks — learned approaches for recurring problems
Conflict Injection
Inject file reservation conflicts into agent prompts for smarter coordination
Plan-Level File Annotations
Parse Files: section in markdown plans for pre-computed file reservations
Batch Scheduling
Atomic batch execution for related tasks from the Agent Flywheel (UBS)
WebSocket Dashboard
Real-time push updates to the web dashboard via WebSocket connections
Cloud Agent Farm
Cloud-hosted agent infrastructure for scalable distributed workloads
Issue Tracking Integration
GitHub Issues and Linear integration for seamless workflow
Agent Leaderboards
Performance metrics and competitive agent rankings
Have a feature request?
Open an issue on GitHubAcknowledgments
Built on Giants
This project integrates and builds upon amazing open-source work.
Jeffrey Emanuel
Creator of the Agentic Coding Tooling Flywheel ecosystem—a comprehensive suite of tools for multi-agent software development.
Flywheel Components:
Steve Yegge
Creator of Beads—a git-backed task management system with dependency tracking and hash-based IDs for conflict-free merging. The foundation of Jetpack's task system.
Key Features:
Turso
Cloud-native libSQL database powering Jetpack's durable DataLayer. Enables embedded replicas, offline sync, and vector search for crash-resilient agent coordination.
Key Features: