An engineering manager
for your AI agents

Describe what you want to build. Delegate breaks it into tasks, assigns agents, manages code reviews, and merges the result. You review the output — not write the code.

Get started View on GitHub
Terminal
# Requires Python 3.12+
pip install delegate-ai
cd /your/project
delegate start

# Spins up a team of agents and opens the console in your browser.
# Tell Delegate what to build — it handles the rest.
Demo
Why Delegate

A different level of abstraction

Copilots help you write code faster — you're still driving. Delegate hands off entire workstreams to a team of agents while you focus on what matters.

Copilots (Cursor, Claude Code, Copilot)
— You are the developerAI assists one task at a time
— SynchronousYou drive every step, wait for output
— One task, one fileContext resets each session
— Disposable agentNo memory of your codebase
— Code suggestionsYou still review and commit
Delegate
+ You set directionAgents plan, code, review, and merge
+ Async by defaultSend a task, close your laptop, come back
+ Many tasks in parallelMultiple projects running simultaneously
+ Persistent teamsAgents learn your codebase over time
+ Reviewed branchesTested, merge-ready output

This isn't a replacement for copilots — it's a different layer. Use Cursor to pair on a tricky function. Use Delegate to hand off "build the auth system" and come back to a reviewed branch.

How it works

You send a task. Agents deliver.

Each task flows through a structured pipeline — plan, code, review, merge — with agents handling every transition.

you
Describe what to build
Send a task in plain English: "Add a /health endpoint that returns uptime and version." Delegate (the manager agent) breaks it into subtasks, assigns them to available engineers, and sets priorities.
1
Engineer writes code
An engineer agent gets an isolated git worktree with its own environment — venv, node_modules, etc. — writes the implementation, runs your test suite, and submits for review. Branches are named delegate/<team>/T0001 — fully visible in your repo.
todo → in_progress
2
Reviewer checks the diff
A second agent reviews the branch, runs the full test suite, checks correctness and readability, and either approves or sends it back with specific feedback.
in_progress → in_review
you
You approve the merge
Browse the diff in the web UI. Approve to merge, or send it back with a comment. Set repos to auto-merge to skip this step entirely.
in_review → in_approval
3
Merge worker lands the branch
The merge worker rebases onto main, runs pre-merge checks, and fast-forward merges. Clean git history, no merge commits. While this happens, you can send more tasks — they run in parallel.
in_approval → done
Features

Built for real engineering work

Not a prototype — Delegate is built with Delegate. Every feature exists because it was needed to ship production code.

//
Many projects, many tasks at once
Spin up a team per project — backend API, mobile app, data pipeline. Within each project, agents tackle multiple tasks in parallel, each in its own git worktree. Throughput scales with teams, not attention.
**
Persistent teams with memory
Create a team once, use it for hundreds of tasks. Agents maintain journals, notes, and context files — they learn your codebase, conventions, and patterns over time. Like a real team, they get better the longer they work together.
~~
Async by default
Send a task and close your laptop. The team keeps working — writing code, reviewing each other, running tests. Check in when you want. No babysitting required. This is the fundamental difference from copilots.
>>
Real git, real branches
Each agent works in an isolated git worktree. Branches are named delegate/<team>/T0001. No magic filesystems — you can git log any branch, git diff any commit, anytime.
⚙
Isolated environments per task
Every worktree gets its own environment — Python venvs, node_modules, Rust targets — so agents never collide. Delegate auto-generates .delegate/setup.sh and .delegate/premerge.sh scripts. They're committed to the repo — edit them if the defaults don't fit.
##
Works with your existing setup
Delegate reads claude.md, AGENTS.md, .cursorrules, and .github/copilot-instructions.md automatically. No migration, no changes to your repos or workflow.
[]
Real-time browser UI
Watch agents pick up tasks, write code, and review each other — live. Approve merges, browse diffs, inspect files, and run shell commands, all from the browser. Installable as a PWA for a native app feel.
+-
Mix models by role
All agents default to Claude Sonnet. Override per agent with --model opus for tasks that need stronger reasoning. Right model for the right job — zero cost when a team is idle.
{}
Customizable workflows
Define your own task lifecycle in Python — add deploy stages, human-in-the-loop checkpoints, or webhook triggers. The default todo → in_progress → in_review → done works out of the box.
Security

Defense-in-depth

Six independent layers of sandboxing. No single bypass compromises the system. Agents can write code — they can't escape their sandbox.

01
Write-path isolation
Every tool call is inspected before execution. Agents can only write to their own directories. Writes outside permitted paths are denied with an error — the model sees it and adjusts.
02
Git command restrictions
Dangerous git operations — rebase, reset --hard, push, fetch, branch manipulation — are hidden from agents at the SDK level. Branch management runs exclusively in the daemon process.
03
OS-level sandbox
All bash commands run inside macOS Seatbelt or Linux bubblewrap. Even if an agent crafts a bypass, the kernel blocks the write. Agents cannot touch unregistered repos or other teams' data.
04
Network domain allowlist
Agents' network access is controlled by an allowlist stored outside the sandbox — agents can't tamper with it. Restrict to specific domains or leave open. Fully configurable via CLI.
05
In-process MCP tools
Agents interact with the database through in-process tools running inside the daemon — outside the sandbox. Agent identity is baked into each tool closure. An agent cannot send messages as another agent.
06
Daemon-managed worktrees
Git worktree creation, branch management, and merge operations run exclusively in the daemon — never in agent sandboxes. Agents commit code inside their worktrees; they cannot create, remove, or manipulate branches.
Roadmap

What's coming

Delegate is under active development. Built with Delegate, by a solo developer. No roadmap theater — these are the actual next items.

If any of these matter to you, open an issue — it helps prioritize.

About

Built by one developer, with Delegate

Delegate is a side project — built because I wanted it for myself and decided to open-source it. No VC funding, no growth targets. MIT licensed, free forever.

The irony: Delegate is built with Delegate. The agents write the features, review each other's code, and merge the results. This isn't a demo — it's the daily workflow.

Install from PyPI Star on GitHub