Introducing Taps: Homebrew for AI Agents

Setting up a good AI coding agent takes real work. You write the system prompt, configure tool permissions, wire up MCP servers, handle dependencies, manage credentials, test edge cases, and iterate until it works. For a Rust-specific agent with security awareness and proper file scoping, that can easily turn into 45 minutes of manual configuration.

Taps collapse that 45 minutes into one command.

What a Tap Actually Is

A tap is not just an MCP server definition. It's a complete agent configuration distributed through a Git repository, the same way Homebrew distributes packages.

Each tap contains:

• Agent manifests — TOML files defining system prompts written by domain experts, model selection optimized for the task, and scoped tool permissions
• Capabilities — MCP server configurations that auto-install dependencies on first run
• Skills — reusable instruction packs with reference documentation and scripts
• Credential management — asks once, stores permanently

When you run octomind run developer:general, Octomind resolves the agent from the tap registry, loads its full configuration, installs any missing dependencies, and starts a session — all in one command.

Using Taps

# List all active taps
octomind tap

# Run any agent from a tap (format: category:variant)
octomind run developer:general
octomind run security:owasp
octomind run lawyer:us
octomind run content:blog

The default tap (muvon/tap) ships with 38 agents across categories:

Adding Third-Party Taps

Taps are Git repositories. Add one from any GitHub org:

# Add a custom tap (clones github.com/myorg/octomind-tap)
octomind tap myorg/tap

# Or link a local directory for development
octomind tap myorg/tap /path/to/local/tap

# Remove a tap
octomind untap myorg/tap

Priority: User-added taps override the default tap. If your org publishes a custom developer:general agent, it takes precedence over the built-in one.

Inside a Tap Repository

A tap is a Git repository with a simple directory structure:

agents/
  developer/
    rust.toml         # octomind run developer:general
    python.toml       # octomind run developer:python
  security/
    owasp.toml        # octomind run security:owasp
skills/
  code-review/
    SKILL.md          # Instruction pack
    references/       # Supporting documentation
    scripts/          # Helper scripts
capabilities/
  websearch/
    tavily.toml       # MCP server configuration
deps/
  ...                 # Dependency definitions

Each agent manifest is a TOML file:

[agent]
name = "Code Reviewer"
description = "Security-focused code review"

[roles.default]
model = "openrouter:anthropic/claude-sonnet-4"
system = """
You are a senior code reviewer. Focus on:
- Security vulnerabilities (injection, XSS, auth bypass)
- Performance bottlenecks and memory leaks
- API contract violations
- Missing error handling at system boundaries

Be direct. Flag issues by severity. Suggest fixes, not just problems.
"""

[roles.default.mcp]
server_refs = ["core", "filesystem"]

The agent manifest defines everything: model selection, system prompt, tool permissions, and capability references. No separate config files, no manual wiring needed.

Why This Matters

For teams: Share a tap repository across your organization. Everyone gets the same agents with the same quality standards. A new developer runs octomind run developer:general and gets your team's coding conventions, security requirements, and review processes baked in.

For domain experts: Package your expertise as a tap. A security consultant publishes security:owasp with years of vulnerability knowledge encoded in the system prompt and tool configuration. Anyone can install and run it.

For fast iteration: Symlink a local directory, edit a TOML file, run the agent. Changes apply immediately — no build step, no publishing, no waiting.

Built-In Skills

Taps also distribute skills — instruction packs that inject domain knowledge into any session without changing the agent persona:

• code-review — structured code review methodology with severity classification
• git-workflow — branching strategies, commit conventions, and PR best practices

Skills load automatically when referenced by an agent, or manually via the built-in skill tool.

What's Next

Browse the full agent registry on the Tap page. Filter by category, read the system prompts, and run any agent with a single command. For the backstory, read why we built the Tap registry — from MCP setup pain to one-command agents.

Building your own? The Tap System Guide covers everything from agent manifests to dependency management and credential handling.