Hand an issue to an agent and review the pull request.
Shipchart passes work from your roadmap to GitHub Copilot or a Linear agent, or runs it on your own machine with shipchart worker. The agent runs on an account or a computer that is already yours, and Shipchart keeps track of what you handed off and what came back.
From a work item
to a pull request
You plan in Shipchart as usual. When a work item is small and clear enough to give away, you choose where it goes. The agent opens a pull request, the work item moves to in review, and merging the pull request marks it done.
- ›Write the work item: a description, acceptance criteria and the files involved
- ›Send it to Copilot, a Linear agent or your own worker
- ›The agent works on a branch and opens a pull request
- ›Read the diff and merge it, or add a note and send it back
Where the work
can go
Each route uses an agent you already have: your Copilot seat, an agent in your Linear workspace, or the coding tools installed on your own machine.
GitHub Copilot
Shipchart creates a GitHub issue, or uses the one you picked, and assigns it to Copilot through the GitHub API. It comments on the issue when Copilot opens a pull request. You need Copilot's coding agent enabled on the repository.
Linear agents
If your Linear workspace has a coding agent installed, such as Codex, Shipchart assigns the Linear issue to it through the Linear API and tracks the delegation next to the others.
Local worker
shipchart worker runs Claude Code, Codex or Gemini on your own machine, in a separate git worktree for each task. The agent pushes a branch and opens a pull request.
Deep Plan
A planning run through the same worker. The agent reads your codebase and writes a plan and a set of work items for one roadmap item. It commits nothing and opens no pull request.
Delegation and the local worker are part of the Builder plan. See what each plan includes.
The whole route,
step by step
Each delegation is recorded against its project with its status, branch and pull request. You can check on one from the project page or with shipchart delegate list.
Plan in Linear,
build on GitHub
Copilot only picks up GitHub issues. If your issues live in Linear, Shipchart creates a matching GitHub issue, assigns it to Copilot, and keeps the Linear issue up to date while the work happens. If Linear has its own agent installed, you can assign the issue to that instead.
- ›Creates the GitHub issue from the Linear one the first time, and reuses it after that
- ›Moves the Linear issue to started when you delegate, and to review when the pull request opens
- ›Marks it complete when the pull request merges, or cancelled if it is closed without merging
- ›Writes the GitHub issue and pull request links into the Linear issue
- ›Assign or reassign any GitHub or Linear issue from Shipchart, or with shipchart issues assign
Run it on
your own machine
shipchart worker is a long-running process in your terminal. It waits for tasks you delegate from the web app, the CLI or your MCP client, and runs each one with a coding agent you already have installed. From a terminal, shipchart work delegate with --runner local sends a work item to it.
- ›Works with Claude Code, Codex and Gemini. With --agent auto it uses whichever of them it finds installed.
- ›Every task gets its own git worktree and branch, so your working copy and any uncommitted changes are left alone.
- ›Runs up to 3 tasks at once by default. Change that with --max-concurrent.
- ›The agent commits, pushes the branch and opens a pull request. The worktree is removed afterwards.
- ›Your repository is not uploaded to Shipchart. The worker sends back status messages, the branch, the commit and the PR link, plus the last lines of output if a task fails.
- ›The agent uses the login or API key already set up on your machine. Shipchart never sees it.
- ›One worker covers every project you have linked with shipchart init, or pass --project to limit it to one. A task is stopped if it runs for more than 30 minutes.
- ›Nobody is there to approve each step, so agents run with their permission prompts turned off. Delegate tasks you have read, and review the pull request before you merge it.
Let the agent read
the code first
Deep Plan is a planning run for one roadmap item. It goes through the same worker, so the agent reads the real repository on your machine. It can ask you a few questions first, and then it writes up what it found.
- ›A summary and a written plan, with the files and existing patterns it found relevant
- ›Work items with a description, acceptance criteria, the files involved and a small, medium or large estimate
- ›Risks, an effort estimate and how confident it is in the plan
- ›Add the work items you want to the worklist, then do them yourself or delegate them
- ›Nothing is committed. The worktree is deleted afterwards, with no branch and no pull request.
Pick a work item
and hand it off
Add a project, write down what needs doing, and decide afterwards who does it.