VoC Agent Implementation Playbook

A concrete build plan for standing up a Voice of the Customer agent system from scratch — week by week, with decision points and milestones.

Prerequisites

Before starting, you need:

• [ ] Access to Gong API (admin must enable, create API credentials)
• [ ] Salesforce API access (connected app with OAuth or API token)
• [ ] A data warehouse (Snowflake, BigQuery, or Postgres — Snowflake preferred)
• [ ] LLM API access (Claude recommended based on Ramp's stack)
• [ ] 1-2 engineers who will own this end-to-end
• [ ] A PM or product ops partner for feedback loops

Phase 1: Data Foundation (Weeks 1-3)

Week 1: Gong Pipeline

1. Set up Gong API credentials — Basic auth, Base64-encoded access key/secret
2. Historical sync — Pull all calls via GET /v2/calls with date range
3. Transcript ingestion — Batch POST /v2/calls/transcript, respect 1K req/hr limit
4. Speaker mapping — Map speakerID to names via /v2/calls/extensive
5. Store raw transcripts — Landing table in your warehouse with call metadata

Week 2: Salesforce Pipeline

1. Set up connected app — OAuth flow or API token
2. Pull core objects — Opportunities, Accounts, Contacts, Cases, Activities
3. Build joins — Link Gong calls to Salesforce opportunities via participant email matching
4. Incremental sync — Set up polling or Change Data Capture for ongoing updates

Week 3: Unified Data Layer

1. dbt models — Transform raw Gong + Salesforce into clean, joined tables
2. Key model: customer_signals — One row per signal (call quote, ticket, survey response) with:
   • signal_id, source (gong/salesforce/zendesk), signal_type (objection/request/praise)
   • customer_id, account_id, deal_stage, segment
   • raw_text, timestamp
3. Test the joins — Verify you can trace a Gong call to a Salesforce opportunity to an account

Milestone: You can query "show me all customer feedback from enterprise accounts in Q1" from your warehouse.

Phase 2: First Agent — Call Summarizer (Weeks 4-5)

Week 4: Single-Call Agent

1. Chunking pipeline — 512-1024 token chunks from transcripts, with speaker labels
2. Vector store setup — Embed chunks (OpenAI, Cohere, or Snowflake Arctic), store in Pinecone/Weaviate/pgvector
3. Build the summarizer agent:
   • Input: a call ID
   • Process: retrieve transcript, extract key themes, objections, requests, competitor mentions
   • Output: structured markdown summary
4. Prompt template — See Prompt Engineering for VoC Agents

Week 5: Multi-Call Synthesis

1. Batch summarizer — Run across a set of calls (e.g., "all calls with Acme Corp in last 90 days")
2. Theme extraction — Identify recurring patterns across multiple calls
3. Cross-reference with CRM — Enrich with deal stage, ARR, segment from Salesforce
4. Output: account briefing — "Here's what Acme Corp cares about based on 12 calls over 90 days"

Milestone: You can generate an account briefing for any customer with Gong calls.

Phase 3: Parallel Agent System (Weeks 6-8)

Week 6: Additional Data Source Agents

Build specialized agents for each source:

Agent	Data Source	Setup Effort
Gong Agent	Call transcripts (already built)	Done
Support Agent	Zendesk/Intercom tickets	Medium — API pull + classification
CRM Agent	Salesforce opportunities/cases	Low — already have data
Usage Agent	Product analytics (Mixpanel/Amplitude)	Medium — depends on analytics stack
Review Agent	G2/Capterra (if applicable)	Low — scrape or API

Week 7: Orchestration Layer

1. Choose orchestration — LangChain (Ramp's choice) or Claude tool_use with parallel execution
2. Coordinator agent — Launches parallel agents, collects markdown artifacts, synthesizes
3. Map-reduce pattern:
   • Map: each agent independently analyzes its source, writes a findings artifact
   • Reduce: coordinator reads all artifacts, identifies cross-source patterns
4. Standardize artifact format — See Prompt Engineering for templates

Week 8: Integration & Testing

1. End-to-end test — Run a full VoC query: "Why are mid-market accounts churning?"
2. Accuracy validation — Have a PM manually verify agent findings against source data
3. Latency tuning — Target < 5 minutes for a full parallel research task
4. Error handling — Graceful degradation when a source agent fails

Milestone: You can ask a strategic question and get a synthesized answer from 3+ data sources in under 5 minutes.

Phase 4: Workflow Integration (Weeks 9-10)

Week 9: PM Workflow

1. Build the PM skill — Following Ramp's three-phase pattern:
   • Frame (questions) -> Research (parallel agents) -> Shape (spec generation)
   • See Product Shaping Workflow
2. Embed in existing tools — Claude Code skill, Slack bot, or internal dashboard
3. Output format — 2-minute-read spec with evidence links

Week 10: Sales Workflow

1. Pre-call briefings — Auto-generate account briefings before sales calls
2. Post-call CRM updates — Extract action items and update Salesforce fields
3. Deal intelligence — Surface relevant VoC signals during pipeline reviews
4. Slack notifications — Alert account owners when new signals emerge

Milestone: PMs and sales reps are using the system in their daily workflows.

Phase 5: Feedback Loops & Optimization (Ongoing)

Weekly

• Product ops reviews agent output vs. raw sources — flags inaccuracies
• Update prompts and retrieval parameters based on feedback
• Monitor token costs and latency

Monthly

• Add new data sources based on signal quality gaps
• Retrain/update embeddings if product language evolves
• Review ROI metrics (time saved, spec quality, deal win rates)

Quarterly

• Evaluate build-vs-buy for components (Actively.ai, Momentum.io)
• Assess whether to expand to new use cases (customer success, marketing)
• Architecture review — is the system scaling?

Decision Points

Decision	Options	Recommendation
Orchestration framework	LangChain vs. native Claude tool_use	Start with Claude tool_use for simplicity, migrate to LangChain if you need 5+ tool integrations
Vector store	Pinecone vs. pgvector vs. Weaviate	pgvector if you're already on Postgres, Pinecone for managed simplicity
Embedding model	OpenAI vs. Cohere vs. open-source	OpenAI text-embedding-3-small for cost/quality balance
Ongoing sync	Webhooks vs. polling	Webhooks for Gong (if available), polling for Salesforce CDC
Support tickets	Zendesk vs. Intercom	Whichever you use — both have good APIs

Cost Estimate

Component	Monthly Cost
LLM API (Claude)	$500-1,500
Vector store (managed)	$100-300
Snowflake compute	$200-500 (incremental)
Engineering time (2 people, 50% for 10 weeks)	~$40K one-time
Ongoing monthly	$800-2,300
Annual run rate	$10-28K

Significantly cheaper than Ramp's $60K/year estimate if you skip some of the enterprise middleware.

Key Takeaways

• Start with data infrastructure (weeks 1-3) — nothing works without clean, joined data
• Build a single-call summarizer first (week 4) to prove value before going multi-source
• Parallel agent architecture is the target state but not the starting point
• Workflow integration (weeks 9-10) is where the ROI actually materializes
• Budget 10 weeks for a functional system, then iterate indefinitely
• Total cost is $10-28K/year run rate plus ~$40K one-time engineering

Related

• Architecture Patterns
• Prompt Engineering for VoC Agents
• Gong Integration
• Salesforce Integration
• GTM Agent Economics