> ## Documentation Index
> Fetch the complete documentation index at: https://docs.honeycomb.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Agent Skills for AI Coding Assistants

> Give your AI coding assistants deep knowledge of observability, OpenTelemetry instrumentation, production debugging, and Honeycomb features.

[Honeycomb Agent Skills](https://github.com/honeycombio/agent-skill) is a collection of skills, agents, and hooks for enhancing AI-assisted code workflows.
These skills provide OpenTelemetry best practices, Honeycomb feature usage, production issue debugging, and more.

## Available skills

Installing the Honeycomb plugin gives your AI assistant eight skills for observability workflows:

* **query-patterns**: Build effective Honeycomb queries with patterns for column selection, filtering, and aggregation.
* **production-investigation**: Debug latency spikes, error rates, and other production anomalies with step-by-step reasoning.
* **slos-and-triggers**: Define and manage SLOs and alert triggers in Honeycomb.
* **otel-instrumentation**: Instrument applications with OpenTelemetry, including span creation, attribute naming, and context propagation.
* **otel-migration**: How to migrate proprietary or legacy instrumentation to OpenTelemetry.
* **beeline-migration**: Guidlines for migrating from Honeycomb Beelines to OpenTelemetry SDKs.
* **observability-fundamentals**: Core concepts around distributed tracing, wide events, and production-grade observability.
* **create-honeycomb-board**: Create Honeycomb boards to capture investigations and share insights.

## Available agents

Two autonomous agents are included for more complex tasks:

* **honeycomb-investigator**: Autonomously investigates production issues by querying Honeycomb data, identifying patterns, and summarizing findings.
* **instrumentation-advisor**: Analyzes your codebase to find instrumentation gaps and suggest improvements based on OpenTelemetry best practices.

## Additional capabilities

* **Column validation hooks**: Prevent queries with invalid or mistyped column names before they are sent to Honeycomb.
* **Schema caching**: Reduce repeated lookups by caching dataset column schemas locally during a session.
* [Honeycomb MCP](/integrations/mcp/) integration: Query traces, check SLOs and triggers, run BubbleUp analysis, and create boards.

## Install the plugin

The following tools support direct plugin installation, which sets up all skills, agents, hooks, and MCP configuration.

### Claude Code

```bash theme={}
claude plugin marketplace add honeycombio/agent-skill
claude plugin install honeycomb
```

After installation, run `/honeycomb-setup` to connect the Honeycomb MCP server and complete authentication.

### Cursor

Add as a remote rule in the Cursor settings:

1. Open **Settings** > **Rules** > **Project Rules**.
2. Select **Add Rule** > **Remote Rule**.
3. Enter the URL: `https://github.com/honeycombio/agent-skill`

### Augment (Auggie CLI)

```bash theme={}
auggie plugin marketplace add honeycombio/agent-skill
auggie plugin install honeycomb
```

### GitHub Copilot CLI

```bash theme={}
copilot plugin install honeycombio/agent-skill:honeycomb
```

### Other tools

Many AI coding tools support skills and MCP servers through their own configuration. To use Honeycomb with these tools, you'll generally need to:

1. **Add skills**: Copy the skill files from the [agent-skill repository](https://github.com/honeycombio/agent-skill) into the skills directory your tool expects.
2. **Configure the MCP server**: Point your tool at the Honeycomb MCP endpoint — `https://mcp.honeycomb.io/mcp` (or `https://mcp.eu1.honeycomb.io/mcp` for EU).

Refer to your tool's documentation for specifics:

| Tool                        | Skills Docs                                                                                                                                                                    | MCP Docs                                                                         |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------- |
| VS Code with GitHub Copilot | [Agent Skills](https://code.visualstudio.com/docs/copilot/customization/agent-skills), [Agent Plugins](https://code.visualstudio.com/docs/copilot/customization/agent-plugins) | [MCP Servers](https://code.visualstudio.com/docs/copilot/chat/mcp-servers)       |
| OpenAI Codex CLI            | [Skills](https://developers.openai.com/codex/skills)                                                                                                                           | [Configuration](https://developers.openai.com/codex/config-reference)            |
| Cline                       | [Rules](https://docs.cline.bot/features/cline-rules)                                                                                                                           | [MCP Servers](https://docs.cline.bot/mcp/mcp-overview)                           |
| Windsurf                    | —                                                                                                                                                                              | [MCP Configuration](https://docs.windsurf.com/windsurf/mcp)                      |
| Amazon Q Developer          | —                                                                                                                                                                              | [MCP Servers](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/mcp.html) |

For tools that only support MCP (not skills), your agent will have access to Honeycomb query tools but won't have the built-in observability reasoning and instrumentation guidance that skills provide.

See the [Honeycomb MCP configuration guide](/integrations/mcp/configuration-guide/) for more details on connecting to the MCP server.

<Note>
  Don't see your tool listed? [Open an issue on GitHub](https://github.com/honeycombio/agent-skill/issues) to request support.
</Note>

## Connecting to Honeycomb

### OAuth (recommended)

OAuth is the recommended authentication method.
It uses a browser-based flow and does not require you to manage API keys.

When you first invoke a Honeycomb MCP tool, your agent will open a browser window to complete the authorization flow.
Pick your Honeycomb environment and grant the required permissions.
Once authorized, your agent can access Honeycomb data for the rest of the session.

### API Key (headless environments)

For autonomous or unattended agents that cannot complete an interactive OAuth flow, use an API key.

1. Generate a Management API key in Honeycomb under **Account** > **Team Settings** > **API Keys**.
2. Grant the **Model Context Protocol** and **Environments** scopes with **Read** permissions (and **Write** if you want the `create_board` tool).
3. Format the key as `KEY_ID:SECRET_KEY` and pass it as a Bearer token in the `Authorization` header.

See the [configuration guide](/integrations/mcp/configuration-guide/#setting-up-an-api-key) for a full example configuration.

### EU region

If your Honeycomb team is on the EU instance, use `https://mcp.eu1.honeycomb.io/mcp` in place of the US endpoint in all configurations above.

## Next steps

* [Getting Started with Honeycomb Using MCP](https://academy.honeycomb.io/app/courses/13ad6a1c-2cd9-46d3-b6c3-c7dc45b5bf4f)
* [Connect your AI agent to Honeycomb MCP](/integrations/mcp/configuration-guide/)
* Browse the [honeycomb/agent-skill repo](https://github.com/honeycombio/agent-skill), open issues, or contribute new skills and improvements.
