# Agent Skills

> Reply.io outbound expertise for AI agents — 18 plain-markdown skills in three installable packs, teaching an agent how outbound actually works, with guardrails and explicit human-approval gates. One command installs them: `reply skills install`. Catalog at github.com/reply-team/reply-skills.

## Status: Available

[reply-skills](https://github.com/reply-team/reply-skills) is the knowledge core of the Reply
Agentic Toolkit: 18 skills that teach an agent how to run real outbound — shape an audience, plan
and launch a campaign, work the replies, read the numbers honestly — with protection guardrails
and explicit human-approval gates for anything that touches a real prospect.

Skills are plain markdown in the open [Agent Skills](https://agentskills.io) format, so they work
in Claude Code, Codex, Cursor, Gemini CLI and any SKILL.md-compatible host.

```
AI agent  →  Reply skills (procedure, guardrails)  →  reply CLI  →  Reply.io v3 API
```

The skill decides *what* to do; the [CLI](/cli) does it.

## Three packs

The outbound expertise is **independent of any product**, and the Reply.io execution layer is a
separate, **replaceable** pack. The core stands on its own, so start with as much or as little as
you want:

| Pack | What it gives your agent | Requires |
|---|---|---|
| **`ai-sdr-core`** (9 skills) | The vendor-neutral core: what an SDR operation *is*, outbound strategy and playbooks, and the guardrails — sending limits, channel limits, approval boundaries. **Works with any provider, or none** — and it is the methodology every other pack builds on, so it is worth installing on its own. | — |
| **`reply-adapter`** (5 skills) | Executes that core against Reply.io: the [CLI](/cli), [API v3](/apis), the [MCP server](/mcp), auth and scopes, error translation, and the mapping from each business operation to the endpoint that performs it. | `ai-sdr-core` + a Reply.io account |
| **`agentic-runtime`** (4 skills) | Durable multi-session work: goals, plans, work items, checkpoints, resumability, reports, user memory. Skip it if your orchestrator already does this. | `ai-sdr-core` |

`ai-sdr-core` and `agentic-runtime` **work with another provider, or with none** — only
`reply-adapter` requires Reply.io and the CLI. That also makes `ai-sdr-core` an easy place to start:
the methodology and guardrails pay off from the first session, with nothing to configure. Add
`reply-adapter` when you want your agent operating Reply.io, and `agentic-runtime` when work needs to
outlive a single session.

## Install

**The recommended way is one command: `reply skills install`.** The [reply CLI](/cli) detects the
AI assistants on your machine and installs the packs into each one, resolving dependencies so
`adapter` brings `core` with it. It is the only channel that resolves dependencies on every host,
and the only one that tells you which hosts are verified — so unless you have a reason to do it by
hand, use it:

```bash
npm install -g reply-cli    # needs Node.js 20 or newer
reply auth login            # OAuth in the browser; no account yet? a Reply.io trial is free
reply skills install
```

```
✓ detected Claude Code, Codex
✓ Claude Code · ai-sdr-core, reply-adapter, agentic-runtime installed
✓ Codex       · ai-sdr-core, reply-adapter, agentic-runtime installed
Start a new session in each assistant so the skills load.
```

Install a subset, target one assistant, or scope the install to a repository:

```bash
reply skills install core              # aliases: core · adapter · runtime
reply skills install adapter runtime
reply skills install --agent codex
reply skills install --project
reply skills list                      # what is installed where
reply skills update                    # bring installed packs to the latest version
```

**Claude Code and Codex are the two hosts this is verified against.** For Cursor, Windsurf,
Gemini CLI and GitHub Copilot the installer writes to each host's documented skills directory,
but that those hosts read from it has not been confirmed — the command says so in its output.

### Without the CLI

A fallback, not an equal alternative: nothing here resolves dependencies for you, so install
`ai-sdr-core` first or the other packs reference guidance that is not present. Claude Code and
Codex read this repository as a plugin marketplace, and the per-host manual steps are in the
[repository README](https://github.com/reply-team/reply-skills#readme):

```bash
claude plugin marketplace add reply-team/reply-skills
claude plugin install reply-adapter@reply-skills   # ai-sdr-core comes with it
```

Then ask your agent things like *"I want to sell into LATAM"*, *"import this CSV and skip
duplicates"*, or *"which sequences are underperforming?"*.

## The catalog

Each skill's frontmatter is its contract — the name, what it does, and when an agent should reach
for it. Every skill is installable and in active refinement; they evolve as the platform and the
models do. The canonical, always-current catalog is
[INDEX.md](https://github.com/reply-team/reply-skills/blob/main/INDEX.md) — agents should fetch
that first. For a browsable version with each skill's trigger conditions, maturity and
dependencies, see the [Skill catalog](https://docs.reply.io/skills/catalog) in the docs.

## `ai-sdr-core` — vendor-neutral outbound expertise

What an SDR operation is, how to plan and run one, and where an agent must stop. No Reply.io
knowledge, no provider required — useful from the first session, with nothing to set up.

- **Operations** — `sdr-operations`: the contract of atomic business operations (add a contact,
  enrol it, pause, reply, classify, read engagement), each carrying whether it is reversible and
  whether it needs a human's approval. Everything else is built on this.
- **Strategy** — `campaign-planning` (a vague goal becomes an executable plan), `audience-building`
  (shape an audience, and name where one comes from when the user has no list yet),
  `campaign-launch` (every precondition checked before anything goes live), `inbox-triage`
  (the replies that matter first, responses sent only after approval), `performance-analysis`
  (an honest read that separates deliverability from copy from targeting)
- **Protection** — `approval-boundaries` (where an agent stops and asks, and the one case where
  acting first is right), `sending-guardrails` (domain authentication, warm-up, volume pacing,
  bounce recovery), `linkedin-guardrails` (invitation pacing, daily limits, recovery when the
  platform flags activity)

## `reply-adapter` — executing that against Reply.io

- **Skills:** `reply-operations-mapping` · `reply-api` · `reply-auth` · `reply-cli` · `reply-mcp`
- `reply-operations-mapping` — each business operation mapped to the endpoint group that performs
  it, the scope it needs, the order to call things in, and how Reply's errors translate back into
  operation outcomes. This is what lets an agent compose correct calls instead of guessing
- `reply-api` — discover endpoints through the machine-readable docs, respect scopes and rate
  limits, handle `problem+json` errors and background jobs
- `reply-auth` — key types (personal, Team, Organization), the `domain:verb` scopes model,
  acting-user headers, and the team resolution errors (`TEAM_REQUIRED`, `USER_REQUIRED`)
- `reply-cli` — sign in, manage profiles and team context, call any v3 endpoint via `reply api`
- `reply-mcp` — connect an MCP client to `mcp.reply.io`, and choose between MCP tools and the CLI
- Composes: [Contact Data API](/apis/contact-data), [Sequence API](/apis/sequences),
  [Conversations & Inbox API](/apis/conversations-inbox), [Analytics API](/apis/analytics)

## `agentic-runtime` — work that survives the session

- **Skills:** `durable-work` · `execution-reporting` · `orchestrator-integration` · `user-memory`
- `durable-work` — goals, plans, work items, checkpoints, approval pauses, recovery and
  resumption, kept as plain markdown in a workspace you own
- `execution-reporting` — reports that become organisational memory: structure, evidence, honest
  deviations, and feeding results back into the next planning pass
- `orchestrator-integration` — which orchestrator owns scheduling and resumption, and how to keep
  two of them from fighting over the same workspace
- `user-memory` — preferences, ICP definitions and playbooks kept so a fresh session does not have
  to ask again

## Safety model

Skills never let an agent start a sequence, send a message, or delete data without your explicit
confirmation in the conversation. Bulk operations show their plan first. Protective actions
(pausing a burning campaign) are the one exception — action first, immediate notification.

The gate is not just prose: it is mechanically bound by
[scoped API keys](https://docs.reply.io/api-reference/authentication) — grant an agent only the
scopes its workflows need.

## The workspace

Long-running campaigns persist state in a **workspace** — a plain-markdown directory (marked by
`reply-workspace.yaml`) holding goals, plans, work items, reports, and your `memory/`. Any agent
can pick up where the last session stopped. Spec:
[workspace-spec.md](https://github.com/reply-team/reply-skills/blob/main/plugins/agentic-runtime/skills/durable-work/references/workspace-spec.md),
shipped inside the `durable-work` skill.

## Source

- Repo: [github.com/reply-team/reply-skills](https://github.com/reply-team/reply-skills) — the catalog is [INDEX.md](https://github.com/reply-team/reply-skills/blob/main/INDEX.md)
- The contract every skill follows: [docs/skill-contract.md](https://github.com/reply-team/reply-skills/blob/main/docs/skill-contract.md)
- Execution layer and installer: [Reply CLI](/cli) ([npmjs.com/package/reply-cli](https://www.npmjs.com/package/reply-cli)) — `reply skills install`
- Docs: [Skills overview](https://docs.reply.io/skills/overview) · [Skill catalog](https://docs.reply.io/skills/catalog) · [Choose your interface](https://docs.reply.io/agents/choose-your-interface)

## FAQ

**Do skills exist today?**

Yes — 18 of them, in three packs. Install the reply CLI, sign in with `reply auth login`, then run
`reply skills install`: it finds the AI assistants on your machine and puts the packs into each
one, dependencies resolved. Claude Code and Codex can also read the repository as a plugin
marketplace directly. The always-current catalog is INDEX.md in the repo.

**What is a skill, concretely?**

A folder of markdown instructions (`SKILL.md` plus supporting files) that an agent platform loads
on demand. It encodes which operation to perform, in what order, what to verify, and where to stop
for human confirmation. There is no runtime code — execution goes through the reply CLI or the
API, so behaviour is deterministic and testable.

**Do I need the CLI to use them?**

For `reply-adapter`, yes — it executes against Reply.io, and the CLI is how it does that.
`ai-sdr-core` and `agentic-runtime` need neither: the first is vendor-neutral outbound expertise and
the second is a way of keeping long work alive across sessions, and both are useful with another
provider, or with none. Install either and your agent gains that knowledge straight away, which makes
`ai-sdr-core` a natural place to start — add `reply-adapter` when you want the agent running real
outreach.

**How is this different from MCP?**

MCP gives an agent tools — individual operations. Skills give it procedure — multi-step workflows
with confirmation gates, verification, and guardrails. They compose: an agent can follow a skill's
procedure using [MCP](/mcp) tools or [CLI](/cli) commands. See
[Choose your interface](https://docs.reply.io/agents/choose-your-interface).

**What if I have no prospect list yet?**

The skills route you rather than refusing. `audience-building` names where an audience comes from
— a list you already have, your own sourcing tooling, the provider's own prospect search where it
has one, or manual research for a short high-value list — and insists the ICP is stated before
sourcing starts, because an audience assembled without one cannot be judged afterwards. On the
Reply side, `reply-operations-mapping` covers [Prospect Search](/apis/prospect-search) and
intent signals as the betas they are, with previewing a search before running it as a hard rule,
and records [Enrichment](/apis/contact-enrichment) as documented but not yet callable. No skill
depends on a capability that is not there.