Build outbound agents in Claude Code and wire them to your stack

You can run outbound research and writing in Claude Code by defining one subagent per job and using hooks to move the results into your stack. Reps keep the selling. The agents handle the preparation around it.

Reps lose hours every week to work that is not selling: researching accounts, building lists, drafting emails, working out what a reply means. Each of those is a well-defined job, which makes it a good fit for a focused agent with its own instructions and tools.

If you do not have the workspace yet, start with setting up Claude Code for GTM. Agents are only as good as the context they read.

The seven agents

Split outbound into jobs that each have one clear input and one clear output:

1. Signal scraper: looks for buying signals such as hiring, funding, launches or leadership changes on a list of accounts.
2. Lead prioritiser: ranks accounts by ICP fit and signal strength so reps work the best ones first.
3. Prospect profiler: builds a short profile of the person and company before first contact.
4. Hook writer: drafts the opening line from the strongest signal and the prospect's role.
5. Sequence builder: turns the hook and angle into a multi-touch cadence across email and LinkedIn.
6. Reply classifier: reads responses, labels them and suggests the next action.
7. Meeting prep: writes a brief before each call from the CRM record, past emails and research.

The first two work best when your signal definitions are written down. See signal-based outbound for how to choose them.

Create the subagents

1. Add one file per agent. Subagents live in .claude/agents/<name>.md. The front matter gives a name, a description Claude uses to decide when to delegate, and optionally the tools the agent may use. The body is its system prompt. An example:

   ---
   name: reply-classifier
   description: Classify a prospect reply and recommend the next step. Use for any inbound reply to an outbound sequence.
   tools: Read, Grep
   ---
   You classify replies to outbound emails.
   
   Read context/icp.md and context/voice.md first.
   
   Label each reply as one of:
   interested, referral, not now, not a fit, unsubscribe, out of office.
   
   Then output:
   label: ...
   reason: one sentence quoting the reply
   next step: what the rep should do
   draft: a short response, only if label is interested or referral

2. Give each agent the least access it needs. A classifier needs to read, not write. A signal scraper may need web access. Limiting tools keeps each agent predictable and makes mistakes cheaper.
3. Define the hand-off format. Agents feed each other, so the output of one must be readable by the next. Have the prioritiser write a ranked file, the profiler write one file per prospect, and the sequence builder read both.
4. Run them on a known list. Pick ten accounts your team already knows well and run the chain. Compare the results with what your best rep would have done, then tighten the instructions.

Wire the output with hooks

Agents produce files and answers. Hooks make something happen when they do. Hooks are configured in .claude/settings.json under hooks, keyed by events such as PreToolUse, PostToolUse, Stop, Notification, SessionStart and UserPromptSubmit. Each hook runs a shell command, so it can call any API.

Useful patterns for outbound:

• Claude finishes a task, a Stop hook posts a summary to a Slack channel
• An enrichment file is written, a PostToolUse hook updates the matching CRM record
• A sequence file is written, a hook loads it into your sequencer as a paused draft
• A content draft is written, a hook sends it to your inbox for review

An example configuration:

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "./scripts/notify-slack.sh" }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          { "type": "command", "command": "./scripts/route-output.sh" }
        ]
      }
    ]
  }
}

The hook receives details of the event as JSON on standard input, including the file path for a write. Your script checks the path, for example sequences/ or enrichment/, and calls the right API. Keep API keys in environment variables, never in the repo.

Keep it safe

• Log every hook action to a file so you can see what was pushed and when
• Make scripts fail loudly and post errors to Slack rather than failing silently
• Check exclusions (customers, open deals, competitors) before anything reaches a sequencer
• Review the whole chain monthly: which agent outputs are still being edited by hand?

Want agents like these built and connected to your stack? Book a GTM Engine Review.

Frequently asked

Do the agents replace SDRs?

No. They remove the preparation work so reps spend more time in conversations. Judgement on who to contact and what to send stays with people.

Do I need Zapier or a similar tool for this?

Not necessarily. Hooks run shell commands, so a short script can call Slack, your CRM or your sequencer directly. An automation platform still helps for complex or long-running workflows.

What is the difference between a skill and a subagent?

A skill is a procedure Claude follows within the current session. A subagent is a separate assistant with its own instructions, context and tool access, which Claude delegates a task to.