Every team that runs coding agents at volume ends up needing the same parts: a work queue, a git worktree per agent, supervision of long-running agent processes, verification runners, a place to review diffs, cost accounting, and memory so agents stop repeating the same mistakes. Many teams build these themselves, starting with a shell script around Claude Code or Codex CLI. Ivy Tendril is that set of parts already built, as a free, source-available desktop application that runs on your machine with any CLI agent. Build your own when orchestration is your product or when your workflow is unusual enough that no fixed lifecycle fits. Use Tendril when you want the parts working this week and want the maintenance to be someone else's job.
What each approach is for
A home-built orchestration usually begins as a convenience: a script that creates a branch, starts an agent with a prompt, and opens a pull request when it exits. It grows when the team wants several agents at once, then wants to see what they are doing, then wants to know what they cost. The result, after a few months, is an internal tool with its own backlog.
Ivy Tendril is for teams that want the outcome of that tool without building it. It runs a fixed lifecycle: idea or ticket, create plan, draft, human reviews the plan, Expand, Split or Update, execute in isolated worktrees, verify with tests, lint and diff, human reviews the diff, pull request, merge. There are exactly two human checkpoints, the plan and the diff, and nothing merges without sign-off. It runs as a desktop application on macOS, Windows, and Linux, or headless with tendril --web, with any CLI agent and your own API keys.
Comparison
| Aspect | Ivy Tendril | Home-built orchestration |
|---|---|---|
| Work queue | Plans, Drafts, Icebox, and Recommendations views | You design and build it |
| Worktree isolation | Automatic, one worktree and branch per plan | You script creation, naming, and cleanup |
| Process supervision | Jobs view with streaming output and execution logs | You handle timeouts, retries, and crashed processes |
| Verification | Tests, lint, and diff per plan; CI imports on Pro | You wire runners to each agent's output |
| Review | Review view with diff and verification tabs | Pull request only, or a UI you build |
| Cost accounting | Per plan and per job, with Dashboard KPIs | You parse usage from each agent's output format |
| Memory | Promptware Memory/ per lifecycle stage, written by the agents | You design storage, retrieval, and injection |
| Agent support | Any CLI agent, switchable per plan | Each agent you integrate and keep current |
| Customization | Promptware programs, tools, and memory; REST API; source available | Unlimited |
| Maintenance | Ivy releases updates | Your team, indefinitely |
| Price | Free; Pro at $59 per user per month | Engineering time |
What a home-built orchestration needs
A queue. Tasks arrive from tickets, bug reports, and chat, and something has to hold them, order them, and hand them to agents. In Tendril this is the Plans, Drafts, and Icebox views, with intake through webhooks, an MCP server, a REST API, and a CLI.
Worktree management. Two agents editing the same checkout will overwrite each other. Each task needs its own git worktree on its own branch, created before the agent starts and removed after the pull request merges. Tendril does this for every plan. See git worktrees for parallel AI agents.
Agent process supervision. CLI agents run for minutes to hours, ask permission questions, hit rate limits, and sometimes exit early. Something must start them with the right flags, capture output, detect a stall, and record what happened. Tendril's Jobs view streams output and keeps execution logs per job.
Verification runners. An agent that reports success is not evidence of success. Tests, lint, and a diff inspection must run against the worktree before a human looks at it. Tendril runs these per plan and shows the results in the Review view. See verification gates for AI-generated code.
A review UI. A pull request page shows a diff, but it does not show which verification steps ran or what the agent cost. Reviewing ten diffs a day through raw pull requests works; reviewing fifty does not. Tendril's Review view puts the diff and the verification results in one place.
Cost accounting. Each agent reports token usage in its own format, if at all. To know what a task cost you must capture usage per run, price it, and aggregate by task. Tendril tracks tokens and cost per plan and per job and shows them on the Dashboard.
Memory. Without memory, every run starts from zero. With memory, you need storage, a way to write learnings after a run, and a way to inject the relevant ones before the next. In Tendril each lifecycle stage is a promptware unit with a Program.md, a Memory/ directory, scoped Tools/, and Logs/. Agents write learnings back and revise their own program. See promptware.
What it costs to maintain
The build is the smaller cost. The larger cost is that every part above depends on something that changes. CLI agents release often, and flags, output formats, and permission modes change with them. Model providers add and retire models. Your repository grows and needs new verification steps. Each change is a small fix, and together they become a standing part-time responsibility for at least one engineer.
There is also the cost of features you never build. Inline plan annotation, plan splitting, voice input, phone access to a running job, and a recommendations view each need design and build work, so a home-built tool rarely gets them.
Human checkpoints and where they go
A home-built loop usually has one checkpoint, the pull request, because that is what already exists. Tendril has two. The plan checkpoint lets you correct scope before an agent runs, comment inline on a draft so the plan is rewritten, or split a plan that is too large. Adding a plan checkpoint to a home-built tool means building a plan format, a drafting step, an editor, and a way to feed the approved plan to the agent.
Parallelism, agent choice, and cost control
Parallel execution is where home-built setups spend most maintenance time: worktree cleanup, port collisions between test runs, and one agent's failure interrupting others. Tendril isolates each plan in its own worktree and branch, and the main branch stays clean until review.
Integrating one agent is a bounded task; keeping five current is a standing job. Tendril lets you switch agent or model per plan without changing the workflow, with keys for Anthropic, OpenAI, Google, OpenRouter, and other providers. Cost per plan lets you compare models on the same kind of task.
When building your own is the right choice
- Orchestration is your product, and you need to own every decision in the loop.
- Your workflow does not end in a pull request, does not use git, or operates on something other than a codebase.
- You need a lifecycle with no human checkpoint at all, for example fully unattended changes in a low-risk repository, and you accept that those changes go unreviewed.
- You are a research group and changing the loop itself is the experiment.
When Ivy Tendril is the right choice
- You want parallel agents, worktree isolation, verification, review, and cost tracking working this week.
- You want two human checkpoints without building a plan format and a review UI.
- You want memory that accumulates across runs without designing the storage.
- You want the maintenance of agent integrations to be Ivy's job. The application is free; see pricing for Pro and Enterprise.
See also agent orchestration patterns for coding agents.
Frequently asked questions
Can I extend Ivy Tendril instead of building from scratch?
Yes. Each lifecycle stage is a promptware unit whose Program.md, Memory/, and Tools/ you can read and edit. The REST API, MCP server, and CLI let you drive Tendril from your own tooling. The source is available under FSL-1.1-ALv2.
Does Ivy Tendril lock me into one agent or model?
No. Tendril runs Claude Code, OpenAI Codex CLI, GitHub Copilot CLI, Google Gemini CLI, OpenCode, and any other CLI agent. You bring your own API keys and switch per plan.
I already have a home-built setup. Can I run both?
Yes. Send a subset of tasks to Tendril through webhooks or the REST API and compare pull request throughput and cost per plan with your current numbers.