Introduction

Kink is a multi-agent orchestration app. Instead of one AI assistant, you run a crew of specialised agents that collaborate on your work — dividing tasks, handing off, and shipping together.

A single agent hits a ceiling: it loses context, stalls, and can't review its own work. Kink gives you a coordinated team — a manager delegates, specialists execute, they talk to each other, and you step in only when it actually matters.

What you get#

Who it's for#

Developers and technical teams who want more than one agent — people running real projects across repositories who need agents to split work and coordinate like a team would.

Where to go next#

• New here? Read How Kink works for the mental model.
• Ready to build? Jump to the Quickstart.
• Prefer a walkthrough? Follow Build your first crew.

How Kink works

The mental model behind Kink: shared ground, specialised agents, and a manager that ties it together.

The core loop#

1. Workspace — you connect folders that become shared context.
2. Crew — agents join the workspace, each with a role and a mission.
3. Goal — you give the crew an objective; the manager decomposes it.
4. Coordination — agents execute, message each other, and hand off work.
5. Supervision — you review, approve, or redirect at key moments.

Three moving parts#

Why multi-agent#

Splitting a goal across specialists means work happens in parallel, each agent stays focused on a narrow scope, and agents review each other — catching mistakes a lone agent would ship. The manager keeps it coherent so you still brief just one point of contact.

Installation

Kink is a native desktop app. Install it, connect a model provider, and you're ready.

Requirements#

Download & install#

1. Download the appGrab the latest build from the download page.
2. Open the disk imageDouble-click the .dmg and drag Kink into Applications.
3. LaunchOpen Kink from Applications and complete first-run setup.

Updates#

Kink checks for updates on launch. When a new version is available you'll be prompted to install it — see the Changelog for what's new.

Quickstart

Get a crew coordinating in a few minutes.

1. Connect a workspacePoint Kink at a folder or repository — this becomes shared ground.
2. Add agentsAdd them one by one, or launch a Manager that recruits the crew.
3. Give a goalDescribe what you want shipped; the manager breaks it into tasks.
4. Run & superviseWatch the crew coordinate; answer any agent that's waiting on you.

# the shape of an agent you set up in Kink
agent Atlas {
  role:    "manager"
  mission: "break the goal into tasks, delegate, roll up results"
  folders: ["~/repos/kink"]
}

Agents & roles

An agent is an autonomous worker with a role, a mission, and a slice of the workspace.

Anatomy of an agent#

Common roles#

• Manager — plans, delegates, and rolls up the crew's output.
• Backend — services, APIs, data.
• Frontend — UI and client code.
• QA — tests and regressions.
• Growth — marketing, docs, outreach.

Roles are conventions, not limits — give an agent any mission and any folders.

Adding & removing#

Add agents from the sidebar or let a manager recruit them. Remove an agent to free its slot; its open handoffs are returned to the manager.

Crews & the manager

A crew is a group of agents working as one. Most crews are led by a manager.

The manager pattern#

A Manager takes a high-level goal, breaks it into tasks, and delegates to specialists. As they finish, it rolls their output back up into a coherent result — so you brief one agent instead of five.

# manager delegates; specialists execute
Atlas (manager)  →  "Echo: update the /users API for the new field"
Atlas (manager)  →  "Forge: adjust the profile component"
Atlas (manager)  →  "Sage: add regression tests"
Atlas (manager)  ←  rolls up results, reports to you

Recruiting#

You can hand-pick agents, or let the manager recruit the crew it needs for the goal. Crews grow and shrink as work demands.

When to skip the manager#

For a single, well-scoped task, one specialist agent is enough. Add a manager when the work spans multiple roles or needs coordination.

Workspace & folders

The workspace is the shared ground your crew operates on.

Connecting folders#

Drop in your folders — no limit. Each becomes shared context every agent can see. A folder like ~/repos/kink shows its assigned agents as a cluster in the sidebar.

Per-agent access#

Assign each agent only the folders relevant to its mission. Backend touches the API folder; frontend touches the app folder; QA sees both.

Multiple workspaces#

Run separate workspaces for separate projects — each with its own crew and folders. See Multiple projects.

Missions & goals

A mission is an agent's standing objective; a goal is what you ask the crew to deliver.

Writing a good mission#

Missions are most effective when they're specific and bounded. Compare:

Goals vs missions#

You hand the crew a goal ("add a verified-email field end to end"). The manager translates it into per-agent tasks that fit each agent's standing mission.

Channels & messages

Agents that truly collaborate — they exchange messages, pass context, and hand off tasks.

Channels#

Agents talk over channels. A channel is live when messages are flowing and idle when it's open but quiet. On the canvas, live channels are solid lines and idle ones are dashed.

Reading a thread#

Every exchange is a structured, human-readable message with a coloured sender. Open a thread to see exactly how a decision was made.

Echo (backend):   "API schema changed — /users returns a new field."
Forge (frontend): "Got it, updating the types and profile component."
Sage (qa):        "Adding regression tests once Forge's PR is up."
Reviewer:         "Looks clean — approving. Ship it when tests are green."

Statuses & lifecycle

Every agent is always in one of three states — and moves between them as work flows.

The three statuses#

A task's journey#

1. Manager assigns a task → the agent goes active.
2. Agent needs a dependency → waiting until the handoff lands.
3. Work completes → results roll up, the agent returns to idle.

Build your first crew

A hands-on walkthrough: ship a small feature end to end with a three-agent crew.

Goal#

We'll add a verified field to a user profile — API, UI, and tests — with a manager coordinating a backend and a frontend agent.

Steps#

1. Connect the repoAdd your project folder as the workspace.
2. Add a managerCreate Atlas (manager) with the mission to deliver the feature.
3. Recruit specialistsLet Atlas recruit Echo (backend) and Forge (frontend), or add them yourself.
4. Give the goal"Add a verified flag to users, surface it in the profile, and cover it with tests."
5. Watch the handoffsEcho updates the API and pings Forge; Forge updates the UI; a reviewer approves.
6. Review & shipInspect the diff, then approve. See Review & approve.

Connect a repository

Point Kink at your code so the crew can read and modify it.

Add a folder#

Choose a project folder or repository root. Kink indexes it as shared context for the workspace.

Version control#

Work on a branch so the crew's changes are isolated and easy to review.

# give the crew a clean branch to work on
git checkout -b feature/verified-users

Scoping folders to agents#

Assign subfolders per agent so each stays in its lane — see Workspace & folders.

Review & approve

Treat the crew like a team whose pull requests you approve.

Inspecting changes#

Before anything ships, review the diff the crew produced. Because every decision is a message, you can trace why a change was made, not just what changed.

Approval gates#

Require your sign-off on risky actions — deletes, migrations, external calls. The agent goes waiting until you approve.

# review what the crew changed
git diff --stat
git diff

Scale a crew

Coordination gets stronger as the crew grows — if you scale deliberately.

When to add agents#

• Work is bottlenecked on one role → add another specialist of that role.
• The goal spans a new domain → add an agent that owns it.
• Reviews pile up → add a dedicated reviewer.

Keeping it coherent#

Let the manager remain the single point of contact. More agents should mean more parallelism, not more things for you to track.

Multiple projects

Run separate workspaces side by side, each with its own crew.

Workspaces as tabs#

Each project gets its own workspace and crew. Switch between them without agents crossing wires — a growth crew on one project won't touch another's repo.

Sharing agents#

Agents are scoped to their workspace. To reuse a setup, recreate the roles in the new workspace; missions and folder scopes carry the intent.

The workspace canvas

A visual map of your crew — every agent has its spot, every channel is visible.

What you see#

• Nodes — agents, coloured by identity, with a live status dot.
• Channels — links between agents; solid when live, dashed when idle.
• Packets — messages gliding along live channels.

Interacting#

Drag nodes to arrange the crew the way you think about it. In the full editor you can also recolour, resize, connect, and rename agents. Try the interactive graph.

Staying in control

Kink runs autonomously, but you're always the supervisor.

Step in only when it matters#

The crew coordinates on its own. Your attention goes to the few moments that need judgment — an ambiguous requirement, a risky change, a trade-off between approaches.

Ways to intervene#

• Answer a waiting agent — unblock the amber status with a decision.
• Redirect — change an agent's mission or reassign folders mid-flight.
• Approve — gate risky actions behind your sign-off.
• Pause — stop the crew and review before continuing.

Models & providers

Kink orchestrates agents on top of leading AI models.

Supported providers#

Connecting a provider#

On first launch, connect your AI provider. Agents then run on that model; a whole crew can share one provider.

Choosing a model#

Default to the most capable model for complex reasoning (manager, review) and lighter models for mechanical work where speed matters.

Settings & permissions

Control what the crew can touch and how autonomously it runs.

Folder permissions#

Grant read/write per folder, per agent. An agent can never act outside the folders it's been given.

Autonomy level#

Agent reference

Every property an agent carries, in one place.

Properties#

Example#

agent Echo {
  role:    "backend"
  mission: "own the /users service; keep API and tests in sync"
  folders: ["~/repos/kink/api"]
  color:   "#6366f1"
}

Keyboard shortcuts

Move around Kink without leaving the keyboard.

Glossary

The vocabulary Kink is built on.

Best practices

Patterns that keep crews fast, focused, and safe.

Scope narrowly#

Give each agent the smallest set of folders and the clearest mission that lets it do its job. Narrow scope = focused agents and reviewable diffs.

One manager, one contact#

Brief the manager, not every specialist. Let it fan work out and roll it back up so your mental load stays flat as the crew grows.

Work on branches#

Always run a crew on a feature branch. It isolates changes and makes review a normal diff.

Loosen autonomy gradually#

Start Supervised, watch a few runs, then move to Balanced once the crew earns trust on that project.

Security & privacy

How Kink handles your code, keys, and data.

Your code stays yours#

The workspace lives on your machine. Agents operate on local folders you explicitly grant — nothing is touched outside them.

Provider keys#

Model-provider keys are stored in Kink's secure settings and used only to run your agents.

Review before external actions#

Gate anything that leaves your machine — pushes, deploys, network calls — behind an approval step.

Troubleshooting

Common issues and how to resolve them.

The app won't open on macOS#

Gatekeeper may block a new app. Approve Kink in System Settings → Privacy & Security, then reopen.

An agent is stuck on "waiting"#

It's blocked on a decision or a handoff. Open its thread — if it needs you, answer it; if it's waiting on another agent, check that agent's status.

Agents aren't changing files#

Check folder permissions — an agent can only write inside folders it's been granted. See Settings & permissions.

The crew is too chatty#

Split overlapping responsibilities so agents stop renegotiating the same boundary. See Scale a crew.

Changelog

What's new in Kink.

v1.0.1 — July 2, 2026#

The first public release of Kink.

• Multi-agent crews with a manager that plans, delegates, and rolls up results.
• Shared workspace — connect folders your crew reads and writes.
• Agent-to-agent communication: channels, handoffs, and readable threads.
• Interactive workspace canvas — drag, connect, recolour, resize, and rename agents.
• Live statuses: active · waiting · idle.
• Per-agent folder permissions and autonomy levels (Supervised · Balanced · Autonomous).
• Claude provider support.