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 across edge cases, and iterate until it actually works. For a Rust-specific agent with security awareness and proper file scoping, that's easily 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, production-ready 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:rust, 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:rust
octomind run security:owasp
octomind run lawyer:us
octomind run content:blog

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

Category	Examples	What they do
Developer	`developer:rust`, `developer:python`, `developer:react`	Language-specific coding with correct idioms
DevOps	`developer:docker`, `developer:kubernetes`, `developer:terraform`	Infrastructure and deployment
Security	`security:owasp`	Vulnerability analysis and security auditing
Legal	`lawyer:us`, `lawyer:de`, `lawyer:uk`	Jurisdiction-specific legal analysis
Content	`content:blog`, `content:seo`	Writing with audience awareness
Launch	`launch:validate`, `launch:pitch`, `launch:brand`	Startup validation and go-to-market

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:rust agent, it takes precedence over the built-in one.

Inside a Tap Repository

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

agents/
  developer/
    rust.toml         # octomind run developer:rust
    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.

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:rust 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.

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