Build Software with an Autonomous AI Team: The Tmux Orchestrator Explained

AI coding tools are constantly evolving. We saw Cursor enhance VS Code with AI, and then AI assistants arrived in our terminals. Claude Code has emerged as one of the most capable coding agents available. But what if you could make Claude Code truly autonomous?

Imagine a system that creates an entire team of AI agents that work together, simultaneously, without direct supervision. This article introduces a groundbreaking workflow that achieves just that, creating a self-managing system that just works.

Core Concepts Explained In 2 Minutes

To grasp why this workflow is so powerful, you need to understand two key concepts that will define the future of how AI agents operate.

1. Tmux: The Terminal Multiplexer

Tmux, or terminal multiplexer, is a program that allows you to create and manage multiple terminal sessions within a single window. When an agent like Claude Code runs in a terminal, it can spawn additional terminals in the same session, assigning specific tasks to each. This means one primary instance of Claude Code can effectively control and manage numerous other instances.

A major benefit is that Tmux sessions persist in memory. When you detach and re-attach, you return to the exact state you left, which is incredibly useful for maintaining context across long-running tasks.

2. Terminal Scheduling

This concept allows you to assign tasks to agents with specific timing parameters. You can instruct them to perform actions at designated times and then automatically proceed to the next task. There's no need for constant monitoring; the agents simply follow the schedule, transforming your terminal into a self-running, automated system.

Setting Up Your Autonomous AI Team

Before starting, navigate to the directory where you want to set up the project.

1. Clone the Repository: First, you'll need the T-Max-Orchestrator repository. Go to your terminal and clone it using the following command: bash git clone <repository_link> This command downloads the repository to your local machine.

2. Run the Setup: After cloning, move into the new T-Max-Orchestrator directory. Once inside, you will run the setup commands. These scripts make all necessary files executable and enable the agentic workflow.

   # Setup commands will be provided by the system later
   

3. Start a Tmux Session: With the setup complete, you need to start a new Tmux session. If you already have one running, you can name the new one to keep things organized. bash tmux new -s my-agent-session This initializes a fresh session for the system to operate within.

Essential Fixes for a Smooth Start

Since this project is relatively new, two errors in the repository need to be corrected for the system to run properly. These are minor changes you can instruct the agent to make.

First Fix: Correcting Hard-Coded Paths

When you first initialize Claude Code inside the Tmux session, you'll provide a specific prompt that explains how the orchestrator works and runs two checks: one to verify Tmux control and another to test the scheduling system.

This initial check will likely fail because the author has hard-coded paths with their own username in the configuration files. Don't worry. Claude will automatically detect this issue and rewrite the paths to work correctly on your system.

Second Fix: Enabling True Autonomy

Next, you need to ask Claude Code to edit the framework's files again. Instruct it to find all instances of the claude command and replace it with claude --dangerously-skip-permissions.

This change is critical. Normally, even with auto-accept enabled, Claude requires approval for certain commands. With this flag, Claude runs all commands automatically. This setting is necessary so that all the different terminals can execute claude commands without requiring you to open each one and approve every action. Without it, the entire system will freeze at the first phase, with all terminals waiting for your input.

The Blueprint: Configuring Your Project Spec

The spec folder is the most critical part of this system; it's where you'll spend most of your time. It acts as the blueprint that tells the orchestrator exactly what application to build.

Inside your project directory, you'll have a structure like this:

• T-Max-Orchestrator/ (The cloned framework)
• app/
  • spec/ (Your project's blueprint)
  • task-manager/ (Where the app gets built)

The spec folder contains several files: - main-spec.md: Includes timing for each development phase. - integration-spec.md: Defines how different parts of the app connect. - frontend-spec.md: Guidelines for the front-end team. - backend-spec.md: Guidelines for the back-end team.

Everything is timed, and Claude Code must complete each phase within its allocated time. You can use a template to create your specs step-by-step, modifying the default requirements for a full-stack web app based on your needs.

Putting It All Together: The Workflow in Action

Once your spec is ready, you'll use a specific prompt to start the build process. After this point, everything runs autonomously.

Your prompt must include: 1. The full path to your spec folder, starting from the home directory (e.g., /home/user/project/app/spec). Relative paths will not work. 2. The teams to create. You can define a front-end team and a back-end team, each with a project manager and a developer. You can add more teams, like an authentication team, using the same format.

The system builds according to your spec, checks on each team every 15 minutes, and regularly commits changes to create restore points.

Here’s a walkthrough of the process:

1. Initialization: After applying the fixes and starting the Tmux session, you initialize Claude with the --dangerously-skip-permissions flag and provide your main prompt.
2. Team Deployment: The system deploys the front-end and back-end teams, sets up their development phases, and schedules 15-minute check-ins.
3. Briefing: It briefs both teams using a script, sending instructions and project specifications from your spec folder to each team's project manager.
4. Execution: The system marks completed tasks on a to-do list and moves to the next phase. It provides status updates detailing each team's progress.

For a more advanced setup, you can include a UI implementation reference in your front-end spec. For example, you can provide a ui-implementation.md file with exact steps for building components with a library like ShadCN.

The result is a multi-terminal environment where agents work and develop independently. You'll see a main agent window, and below it, separate task windows for the front-end and back-end teams. Each team has a window for the project manager, the developer, and a server for running tests—all operating in a closed loop. It's like having multiple engineers working simultaneously, each in their own terminal.

A Smarter Way to Get Started

To understand the workflow and get all the necessary commands, you can explore the GitHub repository. However, a more efficient method is to use a service like Git-Ingest. Simply take the GitHub URL and replace github.com with gitingest.com.

This will summarize the entire repository into AI-readable text. You can copy that summary and paste it into an AI chat model like Claude or ChatGPT. Ask it to explain the workflow and installation process step-by-step, and it will guide you through everything, including all the necessary commands.