How to Build a Full Outbound GTM Agent With Hermes

I built a Hermes GTM agent that can handle almost your entire outbound sales workflow.

Give it your market, offer, and ideal customer. It builds a live pipeline of researched accounts, timely buying signals, ready-to-send outreach, and approved sequences moving across email and LinkedIn.

Instead of starting every day with another prospecting list, you open Telegram to a queue of accounts Hermes has already researched, scored, and prepared for action.

Approve the ones you like and the system runs the outreach, follows every response, updates HubSpot, and stops the moment a prospect replies.

At first, you review every external action. As the research and routing prove reliable, you can give Hermes more autonomy one step at a time.

I built my version with Apollo, Clay, Crustdata, HubSpot, Telegram, Smartlead, and Unipile. You can swap any of them for the tools already inside your GTM stack.

The important part is the workflow connecting them, with Hermes making the decisions between each step.

Here's how it works.

1. Start with the stack you already use

Hermes does not replace your sales tools. It connects them into one workflow.

In my setup:

• Apollo finds accounts and buyers.
• Clay enriches the records.
• Crustdata looks for fresh company and buyer signals.
• Hermes researches, qualifies, and writes.
• Telegram gives me one place to review the work.
• Smartlead handles email.
• Unipile handles LinkedIn.
• HubSpot keeps track of what happened.

You can replace any provider. If you use a different data source, CRM, review interface, or sending tool, the workflow stays largely the same.

The pattern is always:

market -> research -> signal -> message -> approval -> action -> CRM

What disappears is the manual handoff between each step. What does not disappear is your judgment about the market, the offer, and which actions deserve approval.

For the first version, leave Smartlead and Unipile turned off. Let Hermes build the research and review queue before it gets permission to contact anyone.

2. Tell Hermes who you actually want to sell to

Hermes needs something more useful than “find growing SaaS companies that need more pipeline.”

That request leaves it to decide what growing means, which companies count as SaaS, who owns pipeline, which countries are allowed, and what evidence proves a need.

Start with four things:

1. The companies you want.
2. The buyers you want inside those companies.
3. The accounts Hermes should always exclude.
4. The minimum information required before an account can move forward.

Here is a simple version:

account:

industries: [b2b_saas, developer_tools]

employee_range: [50, 500]

countries: [United States, United Kingdom, Ireland, Norway, Sweden, Denmark]

funding_stages: [series_a, series_b, series_c, bootstrapped_profitable]

buyer:

functions: [sales, revenue_operations, growth]

titles: [VP Sales, Head of Sales, Chief Revenue Officer, VP Revenue Operations]

exclude:

[existing_customer, active_opportunity, direct_competitor, agency, suppressed_contact]

required_before_outreach:

[company_domain, named_buyer, current_signal, source, retrieval_date]

Run the exclusion check first.

An existing customer or active opportunity should never re-enter cold outbound because the rest of the account looks attractive. The same applies to competitors, suppressed contacts, and excluded markets.

Email has one additional requirement: a verified address. An account can still qualify for research or LinkedIn without one, but it cannot enter an email sequence.

For the worked example, I use Linear.

Public company material tells us what the business does and identifies a senior sales buyer. That is enough to support the company and buyer fields.

It is not enough to start outreach. We still need a reason to contact the company now.

3. Turn a large market into a short review queue

Now give Hermes its first real job: turn a large market into a small list of accounts worth reviewing.

Here's the workflow:

Apollo finds the market.

Clay fills in the missing company data.

Crustdata retrieves fresh evidence.

Hermes researches and scores the account.

HubSpot stores the result for review.

Apollo handles the broad search. Use the company size, industry, location, technology, job title, and seniority filters from your ICP.

Keep discovery and contact details separate. Finding the right Head of Sales does not mean you have a verified email address for them.

Clay is useful when you want to see the enrichment process inside a table. It can try providers in order and skip expensive checks when the account already failed a cheaper one.

Crustdata handles the freshness pass. This is where Hermes gets recent company, hiring, job, web, and social information instead of relying on an old company profile.

Hermes turns those inputs into one review record.

Every account should answer five questions:

1. Why does this company fit?
2. Who is the likely buyer?
3. What changed recently?
4. Which claims can we support?
5. What should Hermes do next?

If any answer is missing, the account stays out of outreach.

I use a 100-point score to make the decision easier:

• company fit: 25;
• observable problem: 20;
• recent buying signal: 20;
• correct buyer: 15;
• offer relevance: 10;
• evidence quality: 10.

Every point needs a reason. Every reason needs a source and retrieval date.

A simple evidence record looks like this:

claim: Linear launched Loops for Business and Enterprise customers.

source: company product announcement

retrieved_at: 2026-08-09

confidence: high

Before the timing signal is counted, Linear scores 64 out of 100. The company fits, the buyer fits, and the evidence is strong.

The observable-problem score stays low because a public product launch does not prove the company has a private pipeline problem.

This is exactly what you want from the agent. It should be able to say “we do not know” instead of turning every public event into invented pain.

4. Wait for the right moment, not just the right account

Finding the right company is only half the job. Hermes also needs to know why this week is better than six months from now.

So qualified accounts do not go straight into outreach. They enter monitoring and wait until something happens that makes your offer genuinely relevant.

Good signals include:

• a funding round;
• a new executive in the buying function;
• a product or segment launch;
• geographic expansion;
• relevant hiring;
• a technology change;
• a public company priority;
• a competitor change;
• a new compliance requirement;
• a relevant integration.

Each signal needs five fields:

event: what happened

date: when it happened

relevance: why it matters to your offer

source: where the information came from

expiry: when the reason becomes stale

For Linear, the signal is the Loops launch.

The launch is recent, relevant to the example offer, and tied to Business and Enterprise customers. That adds the 20 timing points and moves the account from 64 to 84.

Hermes cron can check monitored accounts on a schedule. Crustdata or another current data source can provide the events.

If Hermes finds an approved signal, the account moves forward. If nothing has changed, it waits.

Expiry matters. A launch from last month may still be relevant. The same announcement next year probably is not.

The loop is now:

find -> qualify -> monitor -> signal -> research -> review

5. Turn the research into outreach

Once the account passes research, Hermes can prepare the message.

Do not give the writing step every scrap of text collected during enrichment. Give it the approved account record and make each sentence earn its place.

There are four sentence types:

1. Fact: a source directly supports it.
2. Inference: a cautious interpretation using words such as “may” or “might.”
3. Offer claim: something your company can genuinely support.
4. Question: a simple call to action that does not assume interest.

The first Linear draft gets this wrong:

Your sales team is probably scrambling to turn Loops into enterprise pipeline.

The public information says Linear launched Loops. It does not say the sales team is scrambling, that pipeline is the problem, or that anyone wants outside help.

A better version stays inside the evidence:

Subject: 10 accounts for the Loops launch

Casey, the Loops launch creates a pretty specific outbound angle: enterprise teams already talking publicly about governed or scheduled agent workflows.

I've been building a system that finds those accounts, maps the right buyer, and prepares outreach around the signal.

Would it be useful if I mapped the first 10 for Linear?

The first sentence is fact. The second is inference. The third is the offer. The last is the question.

If Hermes cannot classify a sentence into one of those four types, remove it.

That one rule eliminates a huge amount of fake personalization.

6. Review the work before it goes live

Start with Hermes sending every proposed action to Telegram.

The review card should show:

• the company and buyer;
• the score and current signal;
• the evidence behind the research;
• the email draft and destination;
• the LinkedIn draft and profile;
• separate controls for each channel.

Email and LinkedIn need separate permission.

Treat email and LinkedIn as two separate switches.

Approving email unlocks Smartlead. Approving LinkedIn unlocks Unipile. If either message changes, that channel locks again until you approve the new version.

In the Linear example, email stays in revision because the demonstration has no verified email address. LinkedIn receives a simulated approval, so only that action can move.

This does not mean a person needs to approve everything forever.

The best way to add autonomy is one layer at a time:

1. Let research run automatically once the account selection stays reliable.
2. Let monitoring run once old signals consistently expire.
3. Let low-risk actions run once the review rules survive enough real examples.
4. Keep high-risk or external actions behind explicit permission.

Do not automate the next layer until you trust the one beneath it.

7. Connect execution without losing control

Once you trust what appears in the review queue, the system starts feeling like an actual GTM machine.

Approve the email and Smartlead can launch it. Approve LinkedIn and Unipile can take over there. Every delivery, bounce, reply, and stop event flows back into HubSpot.

The sending tools execute. HubSpot controls what happens next.

The account moves through a simple sequence:

discovered -> qualified -> monitoring -> signal found -> researched

-> pending review -> approved -> active -> replied -> resolved

Every provider event needs one clear outcome:

• an approved sequence starts: mark the channel active;
• a reply arrives: pause every active channel;
• an unsubscribe arrives: suppress the contact;
• the same event arrives twice: ignore the duplicate;
• a provider keeps failing: create a task and leave the current state unchanged.

This prevents one sending tool from reviving a lead that the CRM has already stopped.

If Smartlead says active while HubSpot says replied, stop. If Unipile says connected while HubSpot says suppressed, stop.

Before you enable real actions, add daily caps, destination checks, duplicate prevention, signal expiry, webhook deduplication, and global unsubscribe handling.

LinkedIn also carries platform and account risk. Using an integration does not remove LinkedIn's rules, so review the current terms before enabling automated actions.

8. Stop everything when someone replies

The most important outbound rule is also the simplest:

Any reply pauses every active channel before classification.

Do this first.

Do not let a model decide whether a reply is important enough to stop follow-ups while another tool continues sending them.

Once the sequence is paused, Hermes can classify the response as:

• positive;
• objection;
• referral;
• not now;
• not interested;
• unsubscribe;
• automatic reply;
• wrong person;
• ambiguous.

It can update HubSpot, notify the owner, create a task, and prepare a suggested response.

It should not send the substantive sales reply automatically.

In the Linear example, a simulated positive response pauses LinkedIn, confirms that email never started, moves HubSpot to replied, and creates a task for a person.

Once the prospect engages, the outbound agent has completed its job. The conversation now belongs to a person.

9. Use the results to improve the next run

This is where the system starts compounding.

Every week, Hermes can break down what happened by segment, signal, buyer, channel, and message angle. It can show which accounts were approved, which messages were rewritten, and which signals produced real conversations.

It can also track the less exciting numbers that protect the system: bounces, unsubscribes, duplicate contacts, and sequences stopped after replies.

Every rate still needs its denominator. Every recommendation still needs the accounts and messages that support it.

Hermes can propose a new signal window, score weight, exclusion, buyer, message angle, or experiment.

Each proposal should include:

what happened

which records support the change

what effect you expect

what could go wrong

how you will test it

when you will roll it back

Then a person decides whether the playbook changes.

The improvement loop is:

results -> proposal -> test -> approval -> new rule

10. Now switch on the full GTM machine

At this point, you have built something genuinely useful.

Hermes can move from a target market to researched accounts, timely signals, channel-ready outreach, approved execution, reply handling, and a cleaner CRM without losing the thread between each step.

Here is how to bring the complete system online without creating a mess:

1. Install the Hermes skill and keep every execution tool in test mode.
2. Write the ICP, buyer roles, exclusions, minimum account record, and offer claims.
3. Connect your account-discovery and enrichment sources.
4. Create the scoring rules and the list of approved signals.
5. Create the HubSpot fields for research, approval, sequence, reply, and suppression.
6. Connect Telegram or another review interface.
7. Ask Hermes to produce a review queue for one narrow market.
8. Review every account, score, signal, and message in the first batch.
9. Add signal monitoring and check that old events expire correctly.
10. Connect email and LinkedIn execution in test mode.
11. Trigger the reply, bounce, unsubscribe, duplicate, stale-signal, and provider-failure scenarios.
12. Go live with a small daily cap and keep the approval queue in place.

Start with 20 to 25 accounts from one segment.

Do not judge the system by how many messages it produces. Judge it by how often you agree with the account, buyer, timing, evidence, and proposed action.

When those decisions are consistently good, increase the autonomy or the volume. Do not change both at the same time.

The old workflow is a chain of manual handoffs across prospecting, enrichment, research, copywriting, sending, and CRM updates.

The new workflow is one loop:

target -> find -> research -> wait -> write -> approve -> send -> stop -> learn

That is what turns Hermes from another writing assistant into a GTM agent that can keep your outbound pipeline moving while you focus on the conversations that actually need you.

If you want more practical AI systems like this, follow me at @VibeMarketer_. Thanks for reading :)