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.
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.
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
Connect the call as the trigger
The meeting recorder is connected so the end of a call is the trigger. When a recording finishes, the transcript fires a fresh session in its own sandbox, seeded with the call. One call maps to one session on one disposable machine, so nothing carries between deals and concurrent calls process in parallel.
Give the agent the recap playbook
How we write a follow-up lives as skills and memory that travel with the agent: the shape of a good recap, how we phrase next steps, which objections need a considered answer, and the account's own history. When a rep improves a recap, we write it down and the agent applies it on the next call.
Connect HubSpot and Linear
Through scoped connectors, brokered server-side so no raw token reaches the model, the agent can:
- Read the transcript — the full call, including the questions raised and what was committed to.
- Update the HubSpot deal — stage, notes, and contacts, written back from what the call actually covered.
- File follow-up tasks in Linear — the concrete next steps, assigned and dated.
- Draft the recap email — summary, answers to the open questions, and clear next steps, ready for the rep.
Set the guardrails
The agent reads the transcript and writes to the CRM and the task tracker on its own, but the outbound email never sends itself. Every recap stops at a human approval gate, so the rep reads it, edits if needed, and sends. Credentials are encrypted in the Secrets Manager and injected at runtime, never shown to the model or written to logs.
Let the follow-up be ready when the call ends
With that in place, hanging up is the whole task. By the time the rep looks, the deal is updated, the tasks are filed, and a recap email is drafted and waiting: the summary, the answers, and the next steps. The rep reviews and sends. The follow-up happens while the call is still fresh instead of days later.
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.
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 microVM sandbox. The session reads only the transcript it's seeded with and reaches only HubSpot and Linear; only the updates and the drafted email leave the sandbox.
- Scoped secrets. The transcript, HubSpot, and Linear credentials are encrypted in the Secrets Manager and injected into the sandbox at runtime, never exposed to the model or the logs.
- 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
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.
Read more
How we keep our docs in sync with the code
The docs agent we run on Kortix — connected to GitHub and our codebase. Once a day it checks the code that landed since its last run and updates the docs those changes affected, opening a PR for review.
How we QA every pull request automatically
The QA agent we run on Kortix — connected to GitHub and our test environment. It checks out each PR, runs the suite, exercises the change, and posts the result.
How we run operations from Slack
A single agent reachable from Slack, with scoped access to our database, Stripe, Linear, and GitHub. Ask in a thread and it runs the task across whatever platforms it needs.
Engineer your first loop
Give your company a workforce of agents that run on a schedule, ship real deliverables, and improve one reviewed change at a time. Free to self-host, managed cloud from $20.
Open source · SSO · RBAC · on-prem · no lock-in