Settings → Hooks is where hooks (local executable + org read-only) are listed.

Your agents can write code and run tests out of the box. But what if you need them to query a database, follow a React best-practices guide, or run a custom security checklist? Extensions add those capabilities.

Open the extension surfaces from Tools (Mod+7).

Overview

Extensions are how you add new capabilities to kill9. There are four types: custom agents, skills, MCP servers, and hooks. Each type extends your agents in a different way — giving them new roles, new knowledge, new tools, or new automations.

You manage extensions in two places: the Tools surface (Mod+7) for detailed management, and the command palette for quick access.

What you can do

With extensions, you can:

Create custom agents for specialized roles unique to your team
Install skills that add domain-specific knowledge to existing agents
Connect MCP servers to give agents access to external tools and APIs
Configure hooks that automate repetitive actions
Browse and install community extensions
Toggle extensions on and off without removing them

How it works

What extensions are

Extensions are composable additions to the kill9 agent system. They don't replace agents — they augment them. An extension adds a specific capability that any agent can use.

The four extension types:

Custom agents — new agents with specific roles, tools, and behavioral rules
Skills — composable behaviors that augment existing agents with specialized knowledge
MCP servers — external tool servers connected via the Model Context Protocol
Hooks — lifecycle automation triggers (covered in Hooks)

The Tools extension surfaces

Press Mod+7 to open Tools, then navigate to the extension section. The Tools surface has tabs for browsing, installing, and managing each extension type.

Browse — Search and discover available extensions. Filter by type: skills, MCP servers, custom agents, or all. Import a skill from GitHub, paste a skill definition, or add an MCP server directly.

Installed — Manage what you have installed. See which extensions are enabled, toggle them on or off, and remove ones you don't use. Disabled extensions remain installed but don't affect agent behavior.

Integrations — Connect kill9 to external systems like GitHub, Linear, Jira, Sentry, and Telegram. Each integration adds context and actions for your agents.

Creating custom agents

You can create agents tailored to your team's needs. A custom agent has:

A name and description — what it does and when to use it
A role definition — the system prompt that shapes its behavior
Tool access — which tools it can use (file editing, bash, search, etc.)
Default model — which AI model powers it by default

Use custom agents when your team has a recurring need that doesn't fit the built-in agents. Examples: a database migration agent that knows your schema conventions, a documentation agent trained on your style guide, or a deployment agent that follows your release process.

Create custom agents in Tools (Mod+7) under the Agents tab.

Managing skills

Skills are lighter than agents. They layer specialized knowledge on top of existing agents without creating a whole new role. A frontend-expert skill might inject React patterns and best practices. A security-audit skill might add OWASP checklists.

Skills can mention each other using the @skill-name syntax, so you can compose complex behaviors from simple building blocks.

Manage skills in the Skills tab of Tools (Mod+7). You can:

Browse available skills and install them
Import skills from GitHub repositories
Create custom skills with your own definitions
Toggle skills on and off
Remove skills you no longer need

Connecting MCP servers

MCP (Model Context Protocol) servers connect external tools and APIs to your agents. When you connect an MCP server, your agents gain access to its tools — without any code changes on the agent side.

Examples of MCP servers you might connect:

A database server that lets agents run read queries
A browser automation server for testing web interfaces
A custom API server for your internal tools
A file server for accessing resources outside the project directory

To connect an MCP server, go to the MCPs tab in Tools (Mod+7). Add the server URL and any required configuration (API keys, authentication tokens). kill9 discovers the server's available tools and makes them available to agents.

Installing plugins

Plugins are pre-packaged extensions that bundle one or more skills, MCP configurations, or custom agent definitions. They're the easiest way to add capabilities — find a plugin, install it, and everything is configured for you.

Browse plugins in the Browse tab. Install with one click. Uninstall just as easily.

Tips

Start with built-in agents and add extensions only when you hit a gap. The default setup covers most development workflows.
Skills are cheaper than custom agents. Try composing skills on top of existing agents before creating a new agent from scratch.
MCP servers run as separate processes. Make sure the server is running and accessible before connecting it.
Check the Installed tab periodically. Extensions you're not using add noise to agent prompts.
If an agent isn't using an extension you installed, check that it's enabled in the Installed tab and that the agent's role supports that extension type.

Skills — what skills are and how to use them
MCPs — configuring MCP servers
Hooks — lifecycle automation
Integrations — connecting external systems
Agents — the built-in agent roster

Extensions