AgentLoop

Autonomous Multi-Agent Orchestration for Software Development

Website •
Installation •
Features •
Commands •
Discord

---

Overview

AgentLoop is an autonomous agent orchestrator that coordinates multiple AI agents working together to complete complex software development tasks. Specialized agents analyze, implement, and test your code—all managed through an intelligent workflow with full human oversight.

Installation

$3

``bash
npm install -g @trygentic/agentloop
`

$3

`bash
npm install @trygentic/agentloop
`

$3

`bash
npx @trygentic/agentloop
`

$3

Native Windows is not currently supported. Please install AgentLoop using WSL (Windows Subsystem for Linux):

`bash


In WSL terminal


npm install -g @trygentic/agentloop
`

$3

`bash


Clone with submodule

git clone --recursive https://github.com/trygentic/agentloop

Or if already cloned

git submodule update --init --recursive

Install and build

npm install
npm run build
`

Quick Start

`bash


Start interactive mode


agentloop
`

$3

On first launch, AgentLoop opens the Model Selection screen. Choose how you want to connect:

1. AgentLoop Subscription - Use subscription credits for premium models
2. Free Models - Provided by OpenCode, no API key required
3. Bring Your Own API Key - Connect your preferred provider:
- Anthropic - Direct API key or Claude Code CLI (recommended for Pro/Max subscribers)
- OpenAI - Direct API key
- Google Gemini - Direct API key
- OpenRouter - Access 100+ models

For Claude models with your Pro/Max subscription:
`bash


Install Claude Code CLI

npm install -g @anthropic-ai/claude-code

Authenticate

claude
`

Then restart AgentLoop—your Claude models will appear automatically.

To change models later, use the /models command.

$3

In interactive mode, you can communicate with agents using natural language—just type your message and press Enter. No slash commands required for conversations. AgentLoop uses tool calls behind the scenes to update the kanban board, manage tasks and dependencies in the DAG, and delegate work to specialized agents like Engineer and QA.

`
> Break down "user authentication" into tasks and add them to the board
> What's the status of task 5? Mark it as in-progress
> Have the engineer agent implement the login API endpoint
> Ask the QA agent to test the new authentication flow
> Add a dependency so task 3 must complete before task 7
> Move all completed tasks to done and show me the kanban board
`

Slash commands (like /orchestrator run or /tasks) are available for system operations, but day-to-day interaction—including task management, agent coordination, and board updates—is conversational.

Architecture

`
┌─────────────────────────────────────────────────────────────────────────────┐
│ AgentLoop CLI │
│ Interactive Mode / Query Mode / Daemon │
└─────────────────────────────────┬───────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ ORCHESTRATOR │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ DAG Task Scheduler │ │
│ │ Manages dependencies, parallelism, and execution order │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ Behavior Tree Engine │ │
│ │ Decision logic, validation layers, AI management │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────┬───────────────────────────────────────────┘
│
┌─────────────────────┼─────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────────┐ ┌───────────────────┐ ┌───────────────────┐
│ Product Manager │ │ Engineer(s) │ │ QA Tester │
│ Agent │ │ Agents │ │ Agent │
│ │ │ │ │ │
│ • Task breakdown │ │ • Code changes │ │ • Test execution │
│ • AGILE planning │ │ • Git operations │ │ • Validation │
│ • User stories │ │ • PR creation │ │ • Issue reporting │
└───────────────────┘ └───────────────────┘ └───────────────────┘
│ │ │
│ ┌───────────┴───────────┐ │
│ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Worktree 1 │ │ Worktree 2 │ │
│ │ (branch-a) │ │ (branch-b) │ │
│ └─────────────┘ └─────────────┘ │
│ │
└──────────────────┬───────────────────────┘
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ Kanban Board │
│ ┌─────────┐ ┌─────────────┐ ┌────────┐ ┌──────┐ ┌─────────┐ │
│ │ Todo │ │ In Progress │ │ Review │ │ Done │ │ Blocked │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ Task 1 │ │ Task 3 │ │ Task 5 │ │Task 7│ │ Task 9 │ │
│ │ Task 2 │ │ Task 4 │ │ Task 6 │ │Task 8│ │ │ │
│ └─────────┘ └─────────────┘ └────────┘ └──────┘ └─────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ External Integrations │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Jira │ │ GitHub │ │ MCP │ │
│ │ Sync │ │ PRs │ │ Servers │ │
│ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
`

$3

1. Task Creation - Define tasks manually, generate them from descriptions using the Product Manager agent, or sync from Jira
2. DAG Scheduling - The orchestrator analyzes task dependencies and creates an optimal execution plan
3. Parallel Execution - Multiple engineer agents work simultaneously on independent tasks
4. Isolated Environments - Each agent can work in its own git worktree or container sandbox
5. Quality Gates - QA agents validate completed work before marking tasks done
6. Continuous Loop - The orchestrator monitors progress and handles failures with self-healing recovery

Features

$3

AgentLoop coordinates multiple specialized AI agents that work together seamlessly:

- Orchestrator Agent - Manages overall workflow, delegates tasks, and ensures smooth handoffs between agents
- Product Manager Agent - Breaks down project descriptions into AGILE tasks, user stories, and sprint plans
- Engineer Agent - Autonomous code implementation with proper git workflows
- QA Tester Agent - Automated testing, issue identification, and validation
- Code Analyzer Agent - Deep codebase analysis for architecture and dependency understanding

$3

Multiple engineer agents can work on different tasks simultaneously, dramatically reducing development time through true concurrency with configurable parallelism limits.

$3

Define task dependencies using a Directed Acyclic Graph (DAG) and let the orchestrator automatically determine the optimal execution order. The system maximizes parallelism while respecting prerequisites and handles complex dependency chains intelligently.

$3

Visual task management with a terminal-based kanban board showing tasks across columns: Todo, In Progress, Review, Done, and Blocked. Navigate, update, and manage tasks directly from the terminal.

$3

Interactive planning sessions help gather requirements, clarify scope, and generate comprehensive task breakdowns. The questionnaire system adapts based on previous answers for intelligent requirements gathering.

$3

- Automatic detection and recovery from orphaned tasks
- Process health monitoring with cleanup of stale executions
- Race condition prevention for task state consistency
- Recovery from crashes and restarts

$3

Configurable, modular decision-making logic for agents using industry-standard behavior tree patterns. Includes validation layers and live AI management for adaptive agent behavior.

$3

Bidirectional synchronization with Jira Cloud:
- OAuth 2.0 and Basic Auth support
- Automatic task syncing
- AI-powered DAG planning from Jira issues
- Sprint and board management

$3

Extend AgentLoop with custom agents, behavior trees, and configurations:
- Custom agent templates using markdown
- Three-layer configuration (build-time, runtime, per-project)
- MCP (Model Context Protocol) integration for external tools

---

Git Worktrees

AgentLoop leverages Git worktrees to enable true parallel development. Each worktree is a separate working directory linked to the same repository, allowing multiple agents to work on different branches simultaneously without conflicts.

`
Main Repository (.git)
│
├── Main Working Directory (main branch)
│
├── .worktrees/
│ ├── feature-auth/ ← Agent 1 working here
│ │ └── (branch: feature/auth)
│ │
│ ├── feature-api/ ← Agent 2 working here
│ │ └── (branch: feature/api)
│ │
│ └── bugfix-login/ ← Agent 3 working here
│ └── (branch: bugfix/login)
`

$3

- No Merge Conflicts During Work - Each agent has its own isolated working directory
- True Parallelism - Multiple agents can compile, test, and modify code simultaneously
- Branch Isolation - Changes in one worktree don't affect others until merged
- Efficient Storage - Worktrees share the same Git objects, minimizing disk usage

$3

| Command | Description |
|---------|-------------|
| /worktrees | Open interactive worktree management view |
| /worktrees list | List all active worktrees |
| /worktrees status | Show worktree status summary |
| /worktrees help | Display worktree usage guide |

---

Container Sandboxing (Podman)

AgentLoop supports optional container-based isolation using Podman, providing an additional layer of security for agent execution. When enabled, agents run inside containers with restricted filesystem and network access.

> Note: Docker support is coming soon.

`
┌─────────────────────────────────────────────────────────┐
│ Host System │
│ │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Podman Container │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ Engineer Agent │ │ │
│ │ │ │ │ │
│ │ │ • Restricted filesystem access │ │ │
│ │ │ • Network isolation (configurable) │ │ │
│ │ │ • Resource limits (CPU, memory) │ │ │
│ │ │ • No access to host system files │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ Mount: /workspace │ │
│ │ │ │ │
│ └───────────────────────┼───────────────────────────┘ │
│ │ │
│ ▼ │
│ Project Directory (read/write) │
└─────────────────────────────────────────────────────────┘
`

$3

- Security - Agents cannot access sensitive files outside the project
- Isolation - Failed or misbehaving agents can't affect the host system
- Reproducibility - Consistent execution environment across different machines
- Resource Control - Limit CPU and memory usage per agent

$3

| Command | Description |
|---------|-------------|
| /setup podman | Interactive Podman installation and configuration |
| /setup podman status | Check Podman installation and container status |
| /setup podman help | Display sandboxing configuration guide |
| /orchestrator sandbox | Manage sandbox settings for agent execution |

---

Background Daemon

The AgentLoop daemon allows you to run the orchestrator as a persistent background service. This is useful for long-running tasks, CI/CD integration, or when you want sessions to survive terminal closures.

`
┌──────────────────────────────────────────────────────────────────┐
│ User Terminal │
│ │
│ $ agentloop $ agentloop │
│ > /daemon start > /orchestrator status │
│ Daemon started ✓ Connected to daemon... │
│ > /exit Orchestrator: running │
│ (terminal closed) Tasks: 3 in-progress │
│ │
└──────────────────────────────────────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────┐
│ Background Daemon Process │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ Orchestrator │ │
│ │ │ │
│ │ • Continues running after terminal closes │ │
│ │ • Processes tasks autonomously │ │
│ │ • Maintains session state and history │ │
│ │ • Reconnectable from any terminal │ │
│ │ • Automatic recovery from interruptions │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ Session Data: ~/.config/agentloop/daemon/ │
│ Logs: ~/.config/agentloop/logs/ │
└──────────────────────────────────────────────────────────────────┘
`

$3

- Long-Running Tasks - Start a large refactoring job and disconnect; reconnect later to check progress
- CI/CD Integration - Run the daemon in your build pipeline for automated code generation
- Remote Development - SSH into a server, start the daemon, disconnect, and reconnect later. You can also work directly on mounted worktrees from your local IDE without needing to SSH
- Persistent Sessions - Conversation history and task state persist across CLI restarts

$3

| Command | Description |
|---------|-------------|
| /daemon start | Start the background daemon service |
| /daemon stop | Stop the running daemon |
| /daemon restart | Restart the daemon (useful after configuration changes) |
| /daemon status | Check if daemon is running and view connection info |

---

Interactive Commands

$3

| Command | Description |
|---------|-------------|
| /help | Show all available commands |
| /exit | Exit interactive mode |
| /clear | Clear conversation history |
| /init | Detect project type and initialize AgentLoop |

$3

| Command | Description |
|---------|-------------|
| /orchestrator run | Run the orchestrator (processes tasks until complete) |
| /orchestrator run --infinite | Run continuously, watching for new tasks |
| /orchestrator generate | Generate AGILE tasks from a project description |
| /orchestrator status | Show current orchestrator status |
| /orchestrator agents | Live agent monitoring with real-time status |
| /orchestrator kanban | Open interactive kanban board |
| /orchestrator stop | Stop the running orchestrator |
| /orchestrator clear | Clear all tasks for the current project |
| /orchestrator logs | Show agent execution logs for a task |

$3

| Command | Description |
|---------|-------------|
| /orchestrator dag | Show DAG status with statistics |
| /orchestrator dag ascii | ASCII visualization of task dependencies |
| /orchestrator dag dot | Export DAG in DOT format |

$3

| Command | Description |
|---------|-------------|
| /tasks | List all tasks in the current project |
| /tasks --status | Filter by status (todo, in-progress, review, done, blocked) |
| /tasks --priority | Filter by priority (low, medium, high, critical) |
| /task add