Skip to content

an open-source alternative to the dots, bots and muses of the world, run an office of claude code/codex like agents on your laptop, sandboxes or anywhere, uses your existing subscriptions

feat(blog): add worktrees-vs-hive, automation, MCP+skills posts (#12,#22,#24)

Chaitanya Giriac26a2c60c25
diff --git a/blog/src/posts/claude-code-automation-while-you-sleep.md b/blog/src/posts/claude-code-automation-while-you-sleep.md
new file mode 100644
index 00000000..3f56ce16
--- /dev/null
+++ b/blog/src/posts/claude-code-automation-while-you-sleep.md
@@ -0,0 +1,150 @@
+---
+title: "Claude Code Automation: Let Agents Build While You Sleep"
+description: "Claude Code automation that runs overnight: set up an autonomous Stop-hook loop, bypass permission prompts safely, and add guardrails so you wake up to progress not chaos."
+date: 2026-06-04
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "claude code automation"
+secondaryKeywords: ["overnight ai coding", "autonomous agents", "run claude code while you sleep"]
+tags: ["Guides", "Automation", "Autonomous", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "How do I make Claude Code keep working without me approving every step?"
+ a: "Run it with a permission mode that bypasses approval prompts for routine actions, and pair that with an autonomous loop so the agent picks up the next task on its own. The safety comes from scoping what it can do and escalating the genuinely risky calls, not from approving each keystroke."
+ - q: "Is it safe to run AI coding agents unattended overnight?"
+ a: "It's safe in proportion to your guardrails. Autonomy without guardrails is how you wake up to a mess. With a clear escalation policy (destructive ops, spend, scope changes go to a human queue), bounded scope, and a full audit log, unattended runs become low-risk and productive."
+ - q: "What does an agent do when it runs out of work overnight?"
+ a: "In a well-built loop it simply stops. The autonomous loop only continues an agent while it has unread tasks in its inbox; when the queue is empty, the Stop hook lets it finish instead of spinning."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Claude Code automation</strong> that
+runs overnight needs three things: an <strong>autonomous loop</strong> so agents pick up the next task
+themselves (built on the <code>Stop</code> hook), a <strong>permission mode that skips routine
+approvals</strong> so they don't stall waiting for you, and <strong>guardrails</strong> — a clear
+escalation policy plus an audit log — so you wake up to progress, not chaos. Autonomy and guardrails
+are the same project, not opposites.</p></div>
+
+The dream is simple: describe what you want, close the laptop, and find it built in the morning. The
+reality is achievable — but only if you build the *guardrails* with the same care as the *autonomy*. An
+agent that never stops to ask is powerful; an agent that never stops to ask *and* has no boundaries is
+a liability. This guide shows how to set up overnight Claude Code automation that's actually safe to
+leave running.
+
+## The two ingredients of autonomy
+
+For an agent to work unattended, it has to clear two hurdles that normally require you:
+
+1. **It can't stop to ask permission for every action.** By default an agent pauses for approval before
+ many operations. Multiply that by a night of work and it'll be stalled on the first prompt while you
+ sleep.
+2. **It can't stop when a task ends.** Finishing one task and going idle is the opposite of overnight
+ progress. The agent needs to reach for the next piece of work on its own.
+
+Solve both and you have automation. Solve them *carelessly* and you have a runaway. The art is solving
+them with the brakes already installed.
+
+## Ingredient 1 — Skip routine approvals (deliberately)
+
+Claude Code can run in a permission mode that bypasses the approval prompt for routine actions —
+effectively "don't ask me before each edit or command." For an unattended run that's not optional;
+it's the difference between an agent that works and one that waits.
+
+In Munder Difflin this is the **auto mode** toggle: when it's on, agents are launched with
+`--permission-mode bypassPermissions` so they proceed without pausing on every step. You'll see the
+exact command in the spawn dialog, so there's no mystery about what's being run.
+
+The important word is **deliberately.** Bypassing approvals is a real grant of authority, so you pair
+it with the boundaries below. Turn it off when you want to confirm each action; turn it on when you've
+scoped the work and you trust the guardrails.
+
+## Ingredient 2 — The autonomous loop
+
+The second ingredient is the loop that keeps an agent moving from one task to the next without you
+handing it each one. The elegant way to build it is on Claude Code's **Stop hook** — the hook that
+fires when an agent is about to finish a turn.
+
+The mechanism, in plain terms: when an agent tries to stop, a hook checks whether it has any unread
+work waiting in its inbox. If it does, the hook returns *"don't stop — here's what's next,"* and the
+agent keeps going. If the inbox is empty, the hook lets it finish. Two safeguards keep this from
+becoming an infinite loop: a flag that prevents blocking a stop twice in a row, and a per-agent cursor
+so each task is surfaced exactly once. The full mechanics are in
+[Claude Code hooks, explained](/blog/claude-code-hooks-explained/).
+
+The crucial property for overnight work: the loop is **driven by a queue, not a timer.** An agent
+continues only while it has tasks; when the work runs out, it stops cleanly instead of spinning or
+inventing busywork. You're not setting a duration — you're filling a queue and letting the team drain
+it.
+
+## Ingredient 3 — Guardrails (the part that makes it safe)
+
+This is where most "let it run overnight" experiments go wrong. Autonomy is easy; *bounded* autonomy is
+the work. Four guardrails turn an unattended run from reckless to routine.
+
+### An explicit escalation policy
+
+Decide, in writing, what the agents are **not** allowed to do on their own — and have those things
+escalate to a human queue instead of executing. A good default critical list:
+
+- **destructive operations** (anything hard to undo),
+- **spending real money**,
+- **scope changes** (work drifting from what you asked), and
+- **conflicts** the team can't resolve.
+
+In a hive, the [orchestrator](/blog/how-the-god-orchestrator-works/) enforces this: routine decisions
+it makes itself, critical ones it routes to an approvals queue. You come back in the morning to a short
+list of "I needed your call on these," not a pile of irreversible actions.
+
+### Bounded scope
+
+Don't point an unattended team at "improve the codebase." Give it a concrete, finishable goal: "add
+validation to these three forms, with tests." Bounded scope means the queue drains to empty — which,
+remember, is what makes the agents stop. Unbounded scope is how you get motion without progress.
+
+### A full audit log
+
+Every action and message should be recorded so you can reconstruct the night. A single-committer git
+repo doubles as that log: each coordination step is a commit you can read back in order. When you wake
+up, "what happened while I was out?" has a precise answer, not a guess.
+
+### Start small, then extend the leash
+
+Run a 30-minute unattended session before you run an 8-hour one. Watch what the agents do with the
+autonomy you've granted, tighten the escalation policy where they overstepped, and only then extend the
+duration. Trust is earned by observation, not assumed.
+
+## A realistic overnight setup
+
+Putting it together, a sane overnight automation looks like this:
+
+1. **Scope a finishable goal** and break it into tasks.
+2. **Turn on auto mode** so agents don't stall on approvals.
+3. **Let the orchestrator route** the tasks into agents' inboxes; the autonomous loop keeps them
+ working through the queue.
+4. **Keep the escalation policy tight** so anything risky lands in the approvals queue instead of
+ happening.
+5. **Close the laptop.** Agents drain the queue, escalate the few things that need you, and stop when
+ the work is done.
+6. **Review the audit log** in the morning — and the short approvals list.
+
+That's automation you can actually sleep through, because the system is built to *stop and ask* exactly
+when it should. It's the practical version of running a coordinated team while you're away, the same
+muscle as [running multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/) — just
+with you out of the room.
+
+## What's still not realistic
+
+Honesty matters here. Unattended agents are great at well-specified, bounded work and at grinding
+through a queue. They're *not* a substitute for your judgment on ambiguous design calls, and they
+shouldn't be handed open-ended mandates with money or production access. The right mental model is a
+diligent overnight shift with a clear ticket list and a manager who escalates — not a genie. Keep the
+goals concrete and the guardrails tight, and the overnight shift earns its keep.
+
+---
+
+Munder Difflin gives you the whole kit: an autonomous Stop-hook loop, an auto mode that skips routine
+approvals, an orchestrator that escalates only the critical few, and a git audit log of the night.
+[Download Munder Difflin](https://munderdiffl.in/#install) to let a hive of Claude Code agents build
+while you sleep; it's free and open source.
diff --git a/blog/src/posts/claude-code-git-worktrees-vs-hive.md b/blog/src/posts/claude-code-git-worktrees-vs-hive.md
new file mode 100644
index 00000000..a41d87a8
--- /dev/null
+++ b/blog/src/posts/claude-code-git-worktrees-vs-hive.md
@@ -0,0 +1,153 @@
+---
+title: "Git Worktrees vs a Hive: Two Ways to Parallelize Claude Code"
+description: "Claude Code git worktrees vs a coordinating hive: when isolated worktrees are enough for parallel agents, and when you need messaging, memory, and an orchestrator on top."
+date: 2026-06-04
+category: orchestration
+categoryLabel: Orchestration
+type: Technical
+primaryKeyword: "claude code git worktrees"
+secondaryKeywords: ["git worktrees", "claude code parallel", "isolated agent workspaces"]
+tags: ["Orchestration", "Git", "Multi-Agent", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "What is a git worktree?"
+ a: "A git worktree is an additional working directory attached to one repository. Each worktree has its own checked-out branch and its own index, but they share the same object store and refs — so you can have several branches checked out at once without cloning the repo multiple times."
+ - q: "Are git worktrees enough to run parallel Claude Code agents?"
+ a: "For independent tasks on separate branches, often yes — worktrees give each agent its own files so they don't collide. What worktrees don't provide is coordination: shared memory, messaging between agents, or an orchestrator that divides one goal across the team."
+ - q: "Can I use worktrees and a hive together?"
+ a: "Yes. Worktrees solve workspace isolation; a hive solves coordination. You can run a coordinated hive where each agent works in its own worktree, getting both isolation and shared memory plus messaging."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p><strong>Git worktrees</strong> give each
+Claude Code agent its own working directory and branch, so parallel agents don't collide on files —
+perfect for <em>independent</em> tasks. A <strong>hive</strong> adds what worktrees don't: shared
+memory, agent-to-agent messaging, and an orchestrator that splits one goal across the team. They solve
+different problems — isolation vs. coordination — and compose: run a hive whose agents each live in a
+worktree.</p></div>
+
+There are two genuinely good answers to "how do I run Claude Code agents in parallel," and they're
+often pitched as rivals. They aren't. Git worktrees and a coordinating hive solve different halves of
+the problem, and the right choice — or the right *combination* — depends on whether your parallel work
+is independent or interdependent. Here's the honest comparison.
+
+## What git worktrees give you
+
+A **worktree** is an extra working directory attached to a single repository. Normally a repo has one
+checkout; `git worktree add ../feature-x feature-x` gives you a *second* directory with the `feature-x`
+branch checked out, sharing the same underlying repo.
+
+```bash
+git worktree add ../agent-a -b agent-a
+git worktree add ../agent-b -b agent-b
+# now agent A and agent B each have their own directory + branch
+```
+
+The key properties:
+
+- **Separate working directories.** Each agent edits files in its own folder. They physically cannot
+ step on each other's uncommitted changes.
+- **Separate indexes.** Each worktree has its own staging area, so an agent staging and committing in
+ one doesn't fight another's index. (This sidesteps a lot of the
+ [`index.lock` pain](/blog/single-committer-git-pattern/) you get when many processes share one
+ index.)
+- **Shared history.** They share the same object store and refs, so branches and commits are visible
+ across all of them — no duplicate clones, no re-fetching.
+
+For **independent** parallel work, this is often all you need. Three agents, three feature branches,
+three worktrees: they run side by side, each on its own task, and you merge the branches when they're
+done. Clean and native.
+
+## Where worktrees stop
+
+Worktrees isolate *workspaces*. They do nothing about *coordination*. The moment your parallel agents
+aren't fully independent, the gaps show:
+
+- **No shared memory.** Agent A figures out a quirk in the build; agent B, in a different worktree, has
+ no idea. Each is its own island. Nothing carries knowledge between them or across sessions.
+- **No messaging.** If agent B needs something from agent A — a decision, an interface, a "don't touch
+ this module" — there's no channel. You become the relay, copy-pasting between directories.
+- **No orchestration.** Worktrees don't divide a *goal* into tasks or assign them. You still decide, by
+ hand, who works on what. There's no coordinator reading "ship feature X with tests and docs" and
+ routing the pieces.
+- **No shared plan or visibility.** Three worktrees are three black boxes. There's no shared board, no
+ roster, no single place to see what the team is collectively doing.
+
+In other words, worktrees make parallel agents *safe to run*, not *able to cooperate*. That's a real
+and useful guarantee — it's just not the same as a team.
+
+## What a hive gives you
+
+A **hive** is the coordination layer worktrees lack. It wraps several long-lived agents and adds:
+
+- **Shared, durable memory.** Each agent's notes persist and become recall-able by the whole team, so
+ knowledge flows between agents and across sessions — [semantic memory for agents](/blog/semantic-memory-for-ai-agents/),
+ not isolated context.
+- **Direct messaging.** Agents send messages to each other through a router; no human relay. ("I own
+ the auth module" actually reaches everyone.)
+- **An orchestrator.** A coordinator decomposes your goal, routes work to the right agent, adjudicates
+ the routine back-and-forth, and escalates only the critical calls — see
+ [orchestrating Claude Code agents](/blog/claude-code-orchestration-guide/).
+- **A shared plan and a live view.** One board, one roster, one office floor you can watch.
+
+What a hive does *not* inherently solve is file isolation — if its agents share a single working
+directory, you need a discipline (single-writer files, single-committer git) to keep them from
+colliding. Which is exactly where worktrees come back in.
+
+## They compose
+
+Here's the punchline the "vs." framing hides: **use both.** Worktrees handle isolation; the hive
+handles coordination. Run a hive whose agents each operate in their own worktree, and you get the best
+of both — agents that can't clobber each other's files *and* can share memory, message each other, and
+take direction from an orchestrator.
+
+```text
+ ┌─ worktree: agent-a (branch agent-a) ─┐
+hive ───────┼─ worktree: agent-b (branch agent-b) ─┼── shared memory + messaging
+(coordination) └─ worktree: agent-c (branch agent-c) ┘ + orchestrator + board
+```
+
+The layers don't conflict; they stack. Worktrees are a git feature for workspace isolation. A hive is a
+coordination feature for teamwork. Asking which to use is like asking whether to use seatbelts or a
+steering wheel.
+
+## A decision guide
+
+Pick based on how *interdependent* your parallel work is:
+
+**Just worktrees** are enough when:
+
+- the tasks are **independent** (separate features, separate branches),
+- agents don't need to know what the others learned, and
+- you're happy to assign work and merge results by hand.
+
+**A hive** (optionally over worktrees) is worth it when:
+
+- the work is **one goal** that needs dividing and recombining,
+- agents must **share knowledge** or **message** each other, or
+- you want to state intent once and have a **coordinated team** execute — the leap described in
+ [how to run multiple Claude Code agents](/blog/how-to-run-multiple-claude-code-agents/).
+
+If you've ever wondered whether built-in mechanisms are enough versus an external coordination layer,
+the same question shows up for [subagents vs a harness](/blog/claude-code-subagents-vs-multi-agent-harness/) —
+and the answer rhymes: native primitives handle the small scale; a coordination layer handles the team
+scale.
+
+## FAQ
+
+**Do worktrees prevent all git conflicts?** They prevent index and working-directory collisions, which
+are the common ones. Shared refs and the object store are still common, so concurrent operations that
+touch refs still want care — which is one reason a hive uses a single committer for its *coordination*
+repo even when agents work in separate worktrees.
+
+**Is a hive heavier than worktrees?** It's more capable, so it's more machinery. If your tasks are
+truly independent, worktrees alone are the lighter, correct choice. Add the hive when coordination —
+not just isolation — is the thing you're missing.
+
+---
+
+Munder Difflin is the coordination layer: shared memory, messaging, and a GOD orchestrator for a hive
+of Claude Code agents — and it plays nicely with the git workflow you already use.
+[Download Munder Difflin](https://munderdiffl.in/#install) when isolation isn't enough and you need a
+team; it's free and open source.
diff --git a/blog/src/posts/mcp-and-skills-in-a-hive.md b/blog/src/posts/mcp-and-skills-in-a-hive.md
new file mode 100644
index 00000000..5db650b8
--- /dev/null
+++ b/blog/src/posts/mcp-and-skills-in-a-hive.md
@@ -0,0 +1,150 @@
+---
+title: "Bringing Your MCP Servers and Skills Into a Hive of Agents"
+description: "How agents in a Claude Code MCP multi-agent hive inherit your existing MCP servers, skills, and tools automatically — and how to scope them per agent by role and directory."
+date: 2026-06-03
+category: guides
+categoryLabel: Guides
+type: Technical
+primaryKeyword: "claude code mcp multi-agent"
+secondaryKeywords: ["mcp servers", "claude code skills", "agent tools"]
+tags: ["Guides", "MCP", "Skills", "Claude Code"]
+author:
+ name: Chaitanya Giri
+ initials: CG
+faq:
+ - q: "Do I have to reconfigure MCP servers for each agent in a hive?"
+ a: "No. Because each agent is a real Claude Code session running in your project, it inherits the MCP servers you've already configured — project-scoped and user-scoped alike. The harness adds coordination on top without touching that configuration."
+ - q: "Do my Claude Code skills work inside a hive?"
+ a: "Yes. Skills resolve the same way they do in a normal session — from your user and project skill directories — so every agent in the hive can use them. The harness doesn't strip or replace your skills."
+ - q: "How do I give different agents different tools?"
+ a: "Scope by directory and role. Project-scoped MCP servers and skills differ per working directory, so an agent pointed at one project gets that project's tools; and each agent's injected role steers which tools it actually reaches for."
+---
+
+<div class="callout tldr"><span class="ic">TL;DR</span><p>In a
+<strong>Claude Code MCP multi-agent</strong> hive, your existing <strong>MCP servers and skills come
+along for free</strong> — because each agent is a real <code>claude</code> session in your project, it
+inherits exactly what a normal session would. The harness only <em>adds</em> coordination (identity,
+hooks, environment); it never strips your tools. To scope tools per agent, lean on
+<strong>per-directory project config</strong> and each agent's <strong>role</strong>.</p></div>
+
+If you've invested in Claude Code — wired up MCP servers, written skills, tuned your tools — the last
+thing you want is a harness that makes you redo all of it per agent. The good news: you don't. The
+design principle that makes a hive practical is that **every agent is a genuine Claude Code session**,
+so your existing setup is inherited, not replaced. This post explains exactly how that works and how to
+scope tools when you want different agents to have different capabilities.
+
+## Why inheritance is automatic
+
+Start from what a hive agent actually *is*. When the harness spawns an agent, it doesn't reimplement
+Claude or run some stripped-down clone. It launches the real `claude` CLI in your project directory,
+and adds a few things via launch flags and environment variables:
+
+- an **injected role and protocol** (via `--append-system-prompt`) so the agent knows who it is and
+ how to coordinate,
+- **lifecycle hooks** (via `--settings`, pointing at a file outside your repo) so the harness can drive
+ the visualization and the autonomous loop,
+- and **environment variables** (`AGENT_ID`, `AGENT_NAME`, and so on) for hive identity.
+
+Notice what's *not* in that list: anything that disables MCP or skills. The agent is a normal session
+with extras bolted on, so it resolves MCP servers and skills the same way every Claude Code session
+does. Your tools are present because nothing took them away.
+
+This is the whole reason a harness is lighter than a framework. A framework asks you to rebuild your
+agent inside it. A harness wraps the agent you already run — which is the core idea behind a
+[multi-agent harness](https://munderdiffl.in/#what), and why your investment carries straight over.
+
+### MCP servers
+
+MCP (Model Context Protocol) servers extend an agent with external tools and data — your database, your
+issue tracker, your internal APIs. Claude Code resolves MCP servers from configuration: user-scoped
+servers you've set up globally, and project-scoped servers defined in the project you're working in.
+Because a hive agent runs as a real session in that project, it picks up both. Every agent in the hive
+can call the same MCP tools you'd have in a solo session — no per-agent re-registration.
+
+### Skills
+
+Skills work the same way. They resolve from your skill directories — the ones a normal session reads —
+so an agent in the hive can invoke any skill you've installed. The harness adds its *own* lifecycle
+hooks via a separate settings file, which is additive; it doesn't shadow or remove the skills your
+session would otherwise have.
+
+## Hooks attach without touching your repo
+
+A natural worry: "if the harness uses `--settings` to attach hooks, does that clobber my settings or
+my MCP config?" It doesn't. The hooks live in a settings file the harness writes **outside** your
+project, and `--settings` is additive — it layers the harness's hooks alongside your existing
+configuration rather than replacing it. Your repo isn't modified to make an agent hive-aware; there's
+no stray settings diff to commit or gitignore. (The hook mechanics are covered in
+[Claude Code hooks, explained](/blog/claude-code-hooks-explained/).)
+
+## A note on the harness's own memory
+
+Here's a deliberate design choice worth calling out: the hive's **semantic memory doesn't consume an
+MCP slot.** Rather than run memory as an MCP server, the harness drives it through a CLI and points each
+agent's environment at a shared store. The benefit is that the coordination layer stays out of your
+tool budget — your MCP servers are yours, and the harness's memory is a companion process beside them,
+not a competitor for the same plumbing. The agent recalls knowledge with plain commands, and your MCP
+configuration is untouched. (The memory layer itself is covered in
+[semantic memory for AI agents](/blog/semantic-memory-for-ai-agents/).)
+
+## Scoping tools per agent
+
+Inheritance gives every agent the *same* tools by default. Often you want differentiation — a
+`db-migrator` with database access, a `docs` agent without it. You scope without fighting the harness,
+using mechanisms Claude Code already provides.
+
+### Scope by directory
+
+MCP servers and skills can be **project-scoped** — defined in a particular working directory. Since
+each agent is spawned with a `cwd`, an agent pointed at one project inherits that project's tools, and
+an agent pointed at another inherits a different set. Directory is your coarse-grained tool boundary:
+put the database MCP server in the project the `db-migrator` works in, and agents elsewhere simply don't
+see it.
+
+### Scope by role
+
+The finer control is the **role** the harness injects into each agent's system prompt. An agent told it
+is the `reviewer` reaches for read and analysis tools; one told it's the `migration` agent reaches for
+the database tools. The role doesn't physically remove a capability, but it steers behavior — a
+well-scoped role keeps an agent in its lane, which is usually what "give this agent different tools"
+really means in practice. Roles are the same routing signal the
+[orchestrator](/blog/claude-code-orchestration-guide/) uses to assign work, so they do double duty.
+
+### Lean on Claude Code's native controls
+
+Because agents are real sessions, Claude Code's own configuration applies — per-project settings and
+permission controls govern what a session in that directory can do. You're not learning a parallel,
+harness-specific permission system; you're using the one you already know, per directory, per agent.
+
+## A practical setup
+
+Putting it together, a tooled-up hive might look like this:
+
+1. **Keep your MCP servers and skills where they are.** User-scoped tools are available to every agent;
+ project-scoped tools follow the project each agent works in.
+2. **Spawn agents with roles that match their tools.** `db-migrator`, `reviewer`, `docs` — the role
+ steers each toward the right subset.
+3. **Point sensitive tools at specific projects** so only the agents in those directories inherit them.
+4. **Let the orchestrator route by role**, so the agent with the right tools gets the matching work.
+
+You end up with a team where each agent has exactly the capabilities its job needs — built entirely
+from configuration you already had, plus roles. That's the fast path from your existing Claude Code
+setup to a coordinated team, which is the same ten-minute on-ramp as the
+[multi-agent setup tutorial](/blog/claude-code-multi-agent-setup-tutorial/).
+
+## FAQ
+
+**Will running many agents multiply my MCP server processes?** It depends on the server and how it's
+launched, just as it would if you opened several Claude Code sessions yourself — the hive doesn't change
+that math. Stateless servers handle it fine; for heavy ones, scope them to the agents that actually
+need them.
+
+**Can an agent use a skill that spawns subagents or runs tools?** Yes — the agent has full Claude Code
+capabilities, including skills and subagents. The harness coordinates *between* agents; it doesn't
+constrain what each agent can do *within* its own session.
+
+---
+
+Munder Difflin runs your real Claude Code — your MCP servers, your skills, your tools — just
+orchestrated into a hive. [Download Munder Difflin](https://munderdiffl.in/#install) to bring your
+existing setup into a coordinated team of agents; it's free and open source.