> For the complete documentation index, see [llms.txt](https://docs.stepsecurity.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.stepsecurity.io/github/ai-agents.md).

# AI Agents

AI coding agents read more from a repository than its source code. When a developer opens a repository in an AI coding agent such as Claude Code, Cursor, or Windsurf, the agent can load the skills committed to it and the plugins the repository's settings enable. A repository can also publish plugins of its own, which developers install onto their machines. Skills and plugins can ship scripts, register hooks, and run shell commands, and whatever runs, runs with the privileges of the developer or automation running the agent.

That makes the agent configuration in your repositories part of your software supply chain. A pull request that adds a skill or changes a plugin can change what every agent session in that repository is able to do, and what every developer who installs the plugin receives.

This section gives you an inventory of the agent skills and plugins in your GitHub organization's repositories, so you can review them with the same care as your CI/CD (continuous integration and continuous delivery) workflows.

To open it, select **AI Agents** in the **GitHub** section of the left navigation.

**What's in this section**

| Page                                                                            | What it shows                                                                                                                                                                                              |
| ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Agent Skills](https://docs.stepsecurity.io/github/ai-agents/agent-skills.md)   | The skills committed to your repositories, which agent loads each one, whether it is managed by the skills.sh CLI (command-line interface) or committed directly, and whether it ships executable content. |
| [Agent Plugins](https://docs.stepsecurity.io/github/ai-agents/agent-plugins.md) | The Claude Code and Codex plugins your repositories publish, the repository and folder each is published from, the repositories whose settings enable it, and the components it supplies.                  |

{% hint style="info" %}
This section covers what is committed to and published from your GitHub repositories. For the skills and plugins installed on developer machines, see [IDE & AI Agents](https://docs.stepsecurity.io/developer-machines/ide-and-ai-agents.md) in Dev Machine Guard.
{% endhint %}

### How Skills and Plugins Reach an Agent

A repository can hand agent capabilities to developers in three ways:

* **Committed skills.** A skill committed to a supported agent folder, such as `.claude/skills` or the shared `.agents/skills`, is available to every developer and every agent session that works in the repository. These appear on **Agent Skills**.
* **Published plugins.** A plugin folder with a `.claude-plugin/plugin.json` or `.codex-plugin/plugin.json` manifest is a plugin that developers install onto their own machines. These appear on **Agent Plugins**, with the repository and commit they are published from.
* **Enabled plugins.** A repository's settings can enable a plugin for everyone who works in that repository. On **Agent Plugins**, the **Used by** section of a plugin lists the repositories that enable it.

Each of these has a counterpart on the developer machine. Once a developer installs a published plugin, Dev Machine Guard reports it on [Agent Plugins](https://docs.stepsecurity.io/github/ai-agents/agent-plugins.md), with the marketplace and repository it came from, and reports the skills it brings on [Agent Skills](https://docs.stepsecurity.io/github/ai-agents/agent-skills.md). Together, the two sections show both ends: what your repositories distribute, and what your developers are running.

### Investigating Across the Section

| If you need to know                                         | Start on                                                                                                    | Then                                                                                                                                                                    |
| ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Which repositories give agents executable skills            | **Agent Skills**, narrowed with the **Any flags** dropdown to `Has code`, `Has hooks`, or `Shell execution` | Open each skill and review its **Declared behavior**, especially **Allowed tools**                                                                                      |
| Where a third-party skill in a repository came from         | **Agent Skills**, filtered to `skills.sh managed`                                                           | Open the skill and check **Provenance** for the upstream source, ref, and lock file                                                                                     |
| What a plugin your organization publishes actually contains | **Agent Plugins**, searched by plugin or component name                                                     | Open the plugin, compare its declared author and repository with **Source**, and review its **Components**                                                              |
| Which repositories enable a plugin for everyone in them     | **Agent Plugins**, sorted by **Used by**                                                                    | Open the plugin and review the repositories listed under **Used by**                                                                                                    |
| Whether a published plugin has reached developer machines   | **Agent Plugins** in GitHub, to identify the plugin and its source repository                               | Search for the plugin on [Agent Plugins](https://docs.stepsecurity.io/github/ai-agents/agent-plugins.md) in Dev Machine Guard to see every device that has it installed |

**Where to Start**

* **Find executable skills first.** On [Agent Skills](https://docs.stepsecurity.io/github/ai-agents/agent-skills.md), skills flagged `code`, `hooks`, or `shell` can run commands when an agent loads or invokes them. Review these before the rest.
* **Check pre-approved tools.** In Claude Code, a committed skill's `allowed-tools` grant applies even when the workspace has not been trusted. Open flagged skills and review **Allowed tools** under **Declared behavior**.
* **Know what you publish.** [Agent Plugins](https://docs.stepsecurity.io/github/ai-agents/agent-plugins.md) lists every plugin your repositories distribute. Confirm each one has an owner, and review its components before developers are encouraged to install it.
* **Review changes in pull requests.** Treat a pull request that adds or changes a skill or plugin with the same scrutiny as a change to a CI/CD workflow.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.stepsecurity.io/github/ai-agents.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
