What AI tools do you use?

We build on top of the tools you already have - HubSpot, Salesforce, n8n, Make - and layer in AI from OpenAI, Anthropic, and others where it makes sense. No proprietary platform, no new vendor to manage.

Is this actual AI or just rule-based automation?

Both, depending on the job. Simple routing and alerts are rule-based - that's the right tool for that. Scoring, summarization, intent detection, and research use real LLMs. We match the approach to the problem.

Do I need to replace my CRM?

No. We build on top of what you have. Whether that's HubSpot, Salesforce, or something else, we connect to it - we don't replace it.

Do I need a technical team to manage this?

No. The automations run on their own. We build it, hand it off, and your team uses the outputs - alerts, scores, summaries - without touching the infrastructure.

How do you handle our data?

Your data stays in your stack. We don't store it, sell it, or route it through proprietary systems. The pipelines we build connect your existing tools directly.

What does onboarding actually look like?

A 30-minute discovery call, then we scope the work and send a proposal. Once you're in, we go heads-down - no lengthy kickoffs or status meetings. You see working software fast.

What if the AI gets it wrong?

It will sometimes, especially early. That's why we build human review steps where it matters and tune based on your data. Accuracy improves over time - it's not set-and-forget.

How is this different from HubSpot's or Salesforce's native AI?

Native AI works within the walls of that one tool. We connect your entire stack and build logic that runs across it - enrichment, scoring, alerts, and summaries that pull from multiple sources and trigger actions anywhere.

How to Connect Gong to HubSpot With AI (Beyond the Native Integration)

Gong’s native HubSpot integration does one thing: it logs calls and syncs transcripts. That’s useful, but it’s table stakes. It doesn’t extract buying signals. It doesn’t score the call. It doesn’t update your MEDDIC fields. It doesn’t tell you whether the deal advanced or stalled. All of that still happens manually - or doesn’t happen at all.

Here’s how to build an AI layer between Gong and HubSpot that actually does something with your call data.

What the native Gong-HubSpot integration does (and doesn’t do)

The native integration handles three things: it logs a call activity in HubSpot when a Gong call is recorded, it attaches the transcript, and it syncs basic metadata like duration and participants.

What it doesn’t do: extract structured information from the call content. Your transcript sits in HubSpot as a wall of text. Nobody reads it. No fields get updated from it. The insights from the call - the prospect’s timeline, their budget mention, the objection they raised - go nowhere unless a rep manually updates their deal record.

The gap this creates: deals stay in the wrong stage, MEDDIC fields stay blank, and the call transcript becomes a compliance artifact instead of actionable intelligence.

The architecture: Gong webhook to AI to HubSpot

The setup has three parts:

Gong webhook fires when a call finishes and analysis is complete (usually 20-30 minutes after the call ends). The webhook payload includes the call ID, participants, and a link to the transcript.

n8n workflow receives the webhook, calls the Gong API to fetch the full transcript, passes it to Claude with a structured extraction prompt, and parses the response.

HubSpot write-back takes the structured output from Claude and updates the deal record - MEDDIC fields, next steps, risk flags, deal stage recommendation.

The whole chain runs automatically. By the time the rep opens HubSpot 30 minutes after their call, the deal is already updated.

Step-by-step: building the Gong-to-HubSpot AI workflow

Step 1: Configure the Gong webhook

In Gong, go to Company Settings > Ecosystem > Webhooks. Create a new webhook pointing to your n8n instance.

Set the trigger to Call Completed (not Call Started - you want the transcript, which isn’t available until Gong finishes processing).

Your n8n webhook URL format: https://your-n8n-instance.com/webhook/gong-call-complete

Step 2: Create the n8n webhook receiver

In n8n, add a Webhook trigger node. Set it to POST, and copy the URL into Gong.

The webhook payload includes callId, startTime, and parties (participants with email addresses). Store callId - you’ll need it to fetch the transcript.

Step 3: Fetch the transcript from Gong

Add an HTTP Request node. Configure it as a GET to:

https://api.gong.io/v2/calls/transcript?ids={{ $json.callId }}

Authentication: Basic Auth with your Gong API credentials (Access Key + Secret, found in Gong Company Settings > API).

The response includes transcript[].sentences[] - an array of sentence objects with speaker, timestamp, and text. You’ll need to flatten this into a readable format.

Add a Code node (JavaScript) to format the transcript:

const sentences = $input.first().json.callTranscripts[0].transcript
  .flatMap(speaker => speaker.sentences.map(s => `${speaker.speakerName}: ${s.text}`));
return [{ json: { transcript: sentences.join('\n'), callId: $('Webhook').item.json.callId } }];

Step 4: Find the associated HubSpot deal

The Gong webhook gives you participant emails. Use them to find the deal in HubSpot.

Add a HubSpot node set to Search CRM Objects > Contacts with filter email = {{ $json.parties[0].emailAddress }}.

Then add another HubSpot node to get associated deals from that contact. Take the first active deal (filter out closedwon and closedlost).

If no deal is found, route to a No Operation node. If multiple deals are found, take the most recently modified one.

Step 5: Call Claude to extract structured data

Add an HTTP Request node configured as POST to https://api.anthropic.com/v1/messages.

Headers:

x-api-key: YOUR_ANTHROPIC_API_KEY
anthropic-version: 2023-06-01
content-type: application/json

Body:

{
  "model": "claude-opus-4-6",
  "max_tokens": 800,
  "messages": [{
    "role": "user",
    "content": "You are a sales intelligence assistant. Analyze this sales call transcript and extract structured information.\n\nTranscript:\n{{ $json.transcript }}\n\nExtract and return ONLY valid JSON with these fields:\n{\n  \"meddic\": {\n    \"metrics\": \"quantified business impact mentioned (or null)\",\n    \"economic_buyer\": \"economic buyer identified (or null)\",\n    \"decision_criteria\": \"evaluation criteria mentioned (or null)\",\n    \"decision_process\": \"buying process steps mentioned (or null)\",\n    \"identify_pain\": \"core pain or problem stated (or null)\",\n    \"champion\": \"internal champion identified (or null)\"\n  },\n  \"next_steps\": \"specific next steps agreed to on the call (or null)\",\n  \"next_step_date\": \"date mentioned for next step in YYYY-MM-DD format (or null)\",\n  \"risk_signals\": \"any red flags or concerns raised (or null)\",\n  \"deal_stage_recommendation\": \"one of: Discovery, Evaluation, Proposal, Negotiation, Closed Won, Closed Lost\",\n  \"call_summary\": \"2-3 sentence summary of what was discussed and agreed\"\n}"
  }]
}

Step 6: Parse the Claude response

Add a Code node to extract the JSON from Claude’s text response:

const text = $input.first().json.content[0].text;
const jsonMatch = text.match(/\{[\s\S]*\}/);
if (!jsonMatch) return [{ json: { error: 'No JSON found' } }];
const parsed = JSON.parse(jsonMatch[0]);
return [{ json: parsed }];

Step 7: Write back to HubSpot

Add a HubSpot node set to Update Deal. Map Claude’s output to your HubSpot deal properties:

meddic_metrics property - maps to meddic.metrics
meddic_economic_buyer - maps to meddic.economic_buyer
meddic_decision_criteria - maps to meddic.decision_criteria
meddic_pain - maps to meddic.identify_pain
meddic_champion - maps to meddic.champion
next_step (text property) - maps to next_steps
close_date - maps to next_step_date if a date was extracted
hs_next_step or a custom notes field - maps to call_summary

If you haven’t created custom MEDDIC properties in HubSpot yet, do that first: Settings > Properties > Deal Properties > Create Property. Use a text field type for each.

Step 8: Update the deal stage (optional)

Add an IF node to conditionally update the deal stage based on Claude’s recommendation. Only update if the recommendation is a progression (not a regression) from the current stage - you don’t want the AI to move a deal backward automatically.

Logic: if deal_stage_recommendation is further along than current dealstage, update the stage. Otherwise, leave it and add the recommendation as an internal note.

Step 9: Send a Slack notification

Add a Slack node to DM the deal owner with a call summary. Format:

*Call logged: {{ dealName }}*
{{ call_summary }}

*Next step:* {{ next_steps }}
*MEDDIC completeness:* {{ non-null MEDDIC field count }}/6 fields

_HubSpot updated automatically._

This closes the loop - the rep knows their deal was updated without opening HubSpot.

What to do about deals with no HubSpot match

Not every Gong call maps to a deal. Discovery calls with new prospects may have a contact but no active deal yet.

Handle this with a branch: if no deal is found, create a HubSpot task for the deal owner to create the deal manually, and include Claude’s call summary in the task notes. This preserves the intelligence without creating junk records.

Calibrating your MEDDIC extraction

The first time you run this, spot-check 10 calls manually. Compare Claude’s extracted MEDDIC fields against what you’d pull from the transcript yourself.

Common gaps:

Metrics: Claude sometimes misses implied numbers (“we’re wasting hours every week” should become a metrics flag even without a hard number)
Economic Buyer: Claude may flag a contact who’s mentioned but not confirmed as a buyer - validate whether your prompt needs to require explicit confirmation language
Champion: The hardest field to extract. Often requires reading tone and context, not just content

Refine your prompt based on what you see. Add examples of what counts as a valid extraction for your sales process. Three or four prompt iterations usually gets you to 85-90% accuracy on the structured fields.

Adding a call scoring layer

Once your extraction is working, add a call quality score. Extend the Claude prompt with:

"call_score": integer 1-10 based on: discovery depth (does the rep ask follow-up questions?), prospect engagement (are they asking questions back?), MEDDIC progress (how many new fields were uncovered?), next step clarity (is the next step specific and dated?)

Write this score to a gong_call_score HubSpot property. Over time, you’ll have deal-level call quality data that correlates with close rate - a leading indicator that no off-the-shelf Gong report gives you.

What this replaces

The typical alternative to this workflow is a Gong Assist setup ($$$), a manual rev ops process where someone audits transcripts weekly, or just not doing it at all. Most teams do the third option.

This workflow runs on your existing Gong subscription, your existing HubSpot instance, n8n (free tier handles the volume for most teams), and Claude API at roughly $0.01-0.03 per call transcript.

For a team running 50 calls per week, you’re looking at $1-2 per week in AI costs to keep every deal record current, every MEDDIC field populated, and every call summarized without a rep touching their keyboard.

The native integration syncs transcripts. This one does the work.

For the deal risk alerting layer that uses this data downstream, see how to set up AI deal risk alerts in HubSpot and Slack. For the pre-call brief that preps reps before they get on Gong in the first place, see the pre-call brief agent.