How we handle the follow-up after every sales call
The call is over, but the work is not. Someone still has to write the recap email, answer the questions the buyer raised, update the CRM and log whatever the team promised. That is easily an hour, and it tends to happen at the end of the day from fuzzy memory, if it happens at all. Plenty of deals go cold after a perfectly good call, simply because nobody followed up in time.
We have an agent on Machine pick up the follow-up as soon as the call finishes. It reads the transcript, writes the recap, updates the deal in HubSpot and logs the tasks in Linear. The email it drafts is held at an approval step until the rep has read it and sent it. This is the process we use after our own calls.
The problem
Deals tend to slip away in the hours after a call. The rep who ran the meeting has all the context fresh, yet every piece of the write-up is manual. Sum up the conversation, answer what was left open, repeat the agreed next steps, log it all in the CRM, create the tasks. Doing it properly eats an hour. Doing it late makes it vague. Skipping it lets the deal go silent.
The usual remedies leave the hard part untouched. A CRM reminder nags you to follow up and does none of the work. A note-taker that drops a raw transcript into the deal still leaves the rep to write the recap, update the CRM and create the tasks. A template email is quick, but it reads like a template and still needs the account details filled in by hand.
What we built
On Machine, finishing a call sets off an agent. Once the recording is done, the transcript opens a session, a fresh cloud computer (a sandbox) just for that call, with narrow access to HubSpot and Linear. The agent reads through the transcript and drafts a recap email that answers the open questions and lays out next steps. It updates the deal's stage, notes and contacts, and logs the follow-up tasks. The email then sits at an approval step until the rep has checked it and hit send.
How it works
Let the end of a call set things off
We connect the meeting recorder so that a finished call is what starts the agent. When a recording wraps, its transcript opens a new session in a sandbox of its own, loaded with that one call. Each call gets its own throwaway computer, so nothing leaks from one deal to another and several calls can be handled side by side.
Teach the agent our recap style
Our way of writing a follow-up is kept in the agent's skills and memory, the playbook it brings into every session. That covers what a strong recap looks like, how we word next steps, which objections deserve a careful reply, and the account's own background. When a rep writes a better recap, we capture it, and the agent uses it on the very next call.
Link HubSpot and Linear
With connectors, narrow links to your tools whose keys stay on our servers so the model never sees a raw token, the agent can:
- Read the transcript. It goes through the entire call, including the questions that came up and the promises that were made.
- Update the deal in HubSpot. Stage, notes and contacts are changed to match what was really discussed.
- Log the next steps in Linear. Each concrete follow-up becomes a task with an owner and a due date.
- Draft the recap email. It writes a summary, answers to the open questions and plain next steps, all ready for the rep.
Decide what it may do alone
On its own, the agent may read the transcript and write to the CRM and the task tracker. The email to the customer is a different matter: it is never sent automatically. Every recap pauses at a human approval gate, where the rep reads it, tweaks it if needed, and sends it. Credentials are stored encrypted in the Secrets Manager and only handed to the agents you grant them to.
Have the follow-up waiting when you hang up
Once this is running, the rep's only job after a call is to hang up. When they next check, the deal has been updated, the tasks are logged, and a recap email sits ready with the summary, the answers and the next steps. They look it over and send it. The follow-up goes out while everyone still remembers the call, not three days later.
The pattern
Each finished call fires a trigger that opens a session with narrow connectors to HubSpot and Linear. Our recap style lives in its skills and memory. The CRM and the tasks update by themselves, while the email to the customer waits at an approval step for the rep.
Guardrails
This agent reads conversations with customers and writes into the CRM, so its reach is narrow and the outbound step belongs to a person:
- Isolation. Each call is handled in a sandbox of its own. The session can read only the transcript it was given and can reach only HubSpot and Linear. The updates and the draft email are all that leave it.
- Scoped secrets. Keys for the transcript source, HubSpot and Linear are stored encrypted in the Secrets Manager and only handed to the agents you grant them to.
- Human approval gate. No recap email ever goes out by itself. Each one waits for the rep to check and send. The agent handles the CRM and the tasks, and the rep owns what goes to the customer.
- Everything is code. The agent's setup, skills and permissions are files in the repo. They keep a version history, and changes go through a reviewed change request instead of a dashboard toggle.
The outcome
Follow-up now goes out while the conversation is still fresh. The deal is current, the tasks are logged, and a recap email is ready to go. Reps spend a minute checking rather than an hour writing, and nothing reaches a customer until a person sends it.
More use cases
How we answer GDPR data-subject requests before the deadline
Our Machine agent checks each GDPR access or deletion request, finds the person's data across our product database, builds the report well within the SLA and hands it to legal before anything is sent.
How we keep our docs matching what the code does
Once a day a Machine agent reads every commit merged since its last pass, finds the doc pages those changes made wrong, rewrites them and sends you one pull request to review.
How we test every pull request without lifting a finger
Our Machine QA agent works with GitHub and our test environment. For each pull request it checks out the branch, runs the tests, tries the change for real, and posts what it found.
Put your first agentto work today.
- SSO
- RBAC
- Governed agents
- Full audit trail