# How we follow up after sales calls

An agent connected to our call transcripts, HubSpot, and Linear that drafts the recap, updates the deal, and files the follow-up tasks, then holds the email for the rep to send.

Canonical page: https://openchatly.com/use-cases/sales-call-followup

After a sales call ends, someone has to write the recap email, answer the
questions that came up, update the CRM, and file whatever the team committed to.
It's an hour of work that usually happens late, half-remembered, or not at all.
The deal stalls not because the call went badly but because the follow-up slipped.

We run an agent on Kortix that does the follow-up the moment a call ends. It reads
the transcript, writes the recap, updates the HubSpot deal, and files the tasks in
Linear, then holds the outbound email at an approval gate so the rep reviews and
sends it. This is how we handle our own post-call follow-up.

- **Team:** Kortix
- **Runs on:** Every sales call, when the recording ends
- **Connected systems:** Call transcript · HubSpot · Linear
- **Mode:** Trigger-driven · email held for the rep

## The problem

The follow-up after a call is where deals leak. The rep just ran the meeting, so
the context is in their head, but the writing-up is manual: recap the discussion,
answer the open questions, restate the next steps, log it in the CRM, and file the
tasks. Done well it takes an hour; done late it's vague; skipped, the deal goes
quiet.

The usual fixes don't close the gap. A CRM reminder tells you to follow up but
doesn't do any of it. A note-taker that dumps a transcript into the deal leaves
the recap, the CRM update, and the tasks for the rep to write by hand. A template
email is fast but generic, and it still needs the account context filled in.

## What we built

On Kortix, the end of a call triggers an agent. When the recording finishes, the
transcript spawns an isolated session (a cloud sandbox) with scoped access to
HubSpot and Linear. The agent reads the transcript, drafts the recap email with
the answers and next steps, updates the deal stage, notes, and contacts, and files
the follow-up tasks. The recap email waits at an approval gate for the rep to
review and send.

## How it works

### Copy the setup prompt into a new session

Open your Kortix workspace, start a new session, paste this prompt and send it.
The agent writes the agent file, the recap skill and the 15-minute trigger, and opens a change request for you to review. Prefer
clicks? Choose **Use this template** instead.

**Setup prompt**

```
Set up a sales call follow-up agent in this workspace.

1. Create the agent agents/sales-call-followup.md. Its job is to turn each finished sales call into an updated deal, follow-up tasks and a drafted recap email. It may use the Google Drive, HubSpot and Linear connectors.

2. Create the skill skills/call-recap/SKILL.md with these rules:
   - Read the full transcript from the Call Transcripts folder in Google Drive. Each call is its own case. Nothing carries over between calls.
   - Match the call to a HubSpot deal from the attendees. If no deal or more than one deal matches, skip the deal update and flag the call instead of guessing.
   - Advance the deal stage only when the call clearly moved it. Append a call summary to the notes and add new attendees as contacts.
   - File one Linear task in Team per commitment, assigned to the rep who hosted the call. If the host is unclear, file it unassigned with a note.
   - Draft the recap email: a short summary, an answer to every open question and the next steps. Hold it for the rep. Never send it.

3. Add a cron trigger call-ended-check to kortix.yaml. It runs the sales-call-followup agent every 15 minutes with the prompt "Load the call-recap skill and process every new call transcript in the Call Transcripts folder since the last run."

4. Tell me which of these connectors are not connected yet.

5. Open a change request with all of it. Do not merge it.
```

### Connect your tools

Open **Connectors** in your workspace and connect the Drive folder your call
recorder writes to, your CRM and your task tracker. Credentials are brokered
server-side and never enter the agent's machine.

- **Google Drive** (Required):
Finds each new call transcript in the connected folder.
- **HubSpot** (Required):
Updates the matching deal with the call outcome.
- **Linear** (Required):
Files one follow-up task per commitment made on the call.

### Run it once with this prompt

Merge the change request, then start a session with the **sales-call-followup**
agent and send this prompt. Check the deal update, the tasks and the draft
before you let the schedule take over.

**Prompt**

```
Process the most recent call transcript in the Call Transcripts folder in Google Drive.

1. Read the full transcript and match it to one HubSpot deal from the attendees. If no deal or more than one deal matches, do not update any deal. Flag the call for me instead.
2. If one deal matches, change its stage only if the call clearly moved it, append a summary to the notes, and add any new attendee as a contact.
3. File one Linear task in Team for each commitment made on the call, assigned to the rep who hosted it.
4. Draft the recap email: summary, answers to the open questions, and next steps. Hold it for review. Do not send it.
```

### Let the 15-minute schedule take over

The change request added this trigger to `kortix.yaml`. From now on the agent
checks for new transcripts every 15 minutes, and each call runs in a new
session on its own cloud computer. To change the interval, edit the cron line,
or open **Triggers** in the workspace.

**kortix.yaml**

```yaml
triggers:
  - slug: call-ended-check
    name: Call-ended check
    on:
      cron: "0 */15 * * * *"
    run:
      agent: sales-call-followup
      prompt: Load the call-recap skill and process every new call transcript in the Call Transcripts folder since the last run.
```

### Hold every recap email for the rep

The deal update and the Linear tasks are written on their own. The recap email
is always a draft, held in the approval channel for the rep to read, edit and
send. A call that matches no deal, or more than one, skips the CRM update and
is flagged so a person links it to the right deal.

### Review the recap draft

Each run ends with an updated deal, filed tasks and one held draft. This is what a run looks like
in the session:

> **Call-ended check · 14:15**
>
> Prompt: Load the call-recap skill and process every new call transcript in the Call Transcripts folder since the last run.
>
> Found **1** new transcript and matched it to one HubSpot deal. Moved the
> deal to **Contract sent**, added **2** new contacts and filed **3** Linear
> tasks. The recap email is drafted and waiting for the rep to review and send.

> **The pattern**
> A **trigger** on the end of each call spawns a session with scoped
> **connectors** into HubSpot and Linear. How we write a recap is encoded as
> **skills** and **memory**. The CRM and tasks update automatically; the outbound
> email waits for the rep at an approval gate.

## Make it do more

Once it works, paste any of these into the same session.

**Prep the next call**

```
Before each scheduled call on an open deal, draft a one-paragraph brief for the rep: the last call's summary, open commitments and unanswered questions.
```

**Chase overdue commitments**

```
Every Friday, list the Linear tasks from call commitments that are past due, and name the deal each one belongs to.
```

**Learn from sent recaps**

```
When I paste a recap the rep sent, compare it to your draft and write the difference into the recap playbook in memory.
```

## Guardrails

The agent reads customer conversations and writes to the CRM, so the access is
scoped and the outbound step stays with a person:

- **Isolation.** Every call runs in its own isolated sandbox. The session reads only
  the transcript it's seeded with and reaches only HubSpot and Linear; only the
  updates and the drafted email are written back out.
- **Scoped secrets.** The transcript, HubSpot, and Linear credentials are encrypted
  in the Secrets Manager and injected into the sandbox at runtime, scoped to the agents you grant them to.
- **Human approval gate.** The recap email never sends on its own. Each one is held
  for the rep to review and send; the agent writes to the CRM and tasks, the rep
  owns the outbound.
- **Everything is code.** The agent's configuration, skills, and permissions are
  files in the repo, versioned and changed through a reviewed **change request**
  rather than a dashboard setting.

## The outcome

- **Every call:** Recap, CRM update, and tasks ready when it ends
- **Rep sends:** The outbound email is always reviewed by a person
- **3 systems:** Transcript, HubSpot, and Linear in one agent

The follow-up now happens while the call is still fresh: the deal is updated, the
tasks are filed, and a recap email is drafted and waiting. The rep spends a minute
reviewing instead of an hour writing, and no email goes out without a person
sending it.
