Video summary

The Building Blocks of GTM Orchestration — Arman Vaziri, Ramp

Main summary

Key takeaways

Technology

Summary of technological concepts & product/engineering features (GTM orchestration)

Goal: “Describe intent” to automate go-to-market execution

The talk frames go-to-market orchestration as the ability to take a motion (e.g., playbooks, experiments, evergreen campaigns) described at a high level and automatically distribute/execute it across channels (outbound, ads, web, in-app, etc.).

Automation should generate the outputs needed to run campaigns—such as audiences, incentives, messaging, creative, and notifications—based on intent, while reducing coordination overhead.

Why this is hard: coordination and data consistency

Key bottlenecks include:

  • Messy/inconsistent data across systems: teams often operate from different “sources of truth,” making coordinated targeting and execution difficult.
  • Reps buried in busywork: even with good ideas, scaling experimentation/creativity is hard because sales is overloaded.
  • Coordination/distribution between systems and channels is expensive and slow, not feasible on a “weeks” pace without automation.

Overall approach: build foundations vertically, then scale horizontally

The speaker describes a progression:

  1. Ingestion + consistency + data quality (build a consistent data foundation)
  2. Vertical efficiency/growth levers (save time, improve conversion/performance via personalization and better creative)
  3. Horizontal scaling across teams using reusable patterns, skills, integrations, and ingestion pipelines
  4. Final emphasis: multi-channel, multi-team distribution driven by intent

Building block #1: Internal customer data platform (CDP-like foundation)

Ramp builds an internal Customer Data Platform (CDP)-style layer to unify customer/market/context data.

Data sources included

  • CRM data
  • Product data
  • Enrichment data
  • Web data / buying signals (including modeled internal propensity signals)
  • External signals (e.g., funding announcements)
  • Interaction data: emails, meetings, calls, page views

Real-time event pipeline

  • Events (e.g., emails) are piped into Kafka topics
  • Consumers process events and push them into storage

Storage + guarantees

  • Data lands in a Postgres-backed layer to maintain transactional guarantees and referential integrity between entities across CRM/product/third parties.
  • Strong emphasis on attribution/metadata: where data came from and when it arrived.

Unstructured data handling

Sales data is often unstructured (call transcripts, emails, notes). The system aims to support search across it.

Batch + warehouse processing

  • Uses DBT + Snowflake for offline batch compute
  • Then performs reverse ETL back into the operational layer

Pre-computation

  • Pre-processes enrichment for:
    • “who to sell to”
    • “who already uses us”
  • Goal: reduce runtime cost for orchestration.

Building block #2: Durable execution for agents (system-level reliability)

Complex workflows require agents to run tasks reliably over time.

Temporal for durable threads

The system uses Temporal to represent work as durable threads:

  • Each tool call / model call is an activity
  • If workers fail, execution can resume from the last known state instead of recomputing

Additional capabilities

  • Config-scoped tool calls (agents get different tool access based on needs)
  • Human-in-the-loop support (pause execution for input and resume)

Building block #3: Retrieval over unstructured knowledge (embeddings + scoped search)

To avoid stuffing entire corpora into agent context, the system:

  • Ingests knowledge such as:
    • enablement materials
    • playbooks
    • product knowledge
  • Performs chunking + embeddings into a vector database (referred to as “Turbo Buffer”)
  • Enables vector search + attribute/keyword search
  • Retrieves only what’s relevant to a given account/context (scoped retrieval)

Example vertical use case: Pre-meeting briefs for AMs

A concrete example is generating pre-meeting briefs for account managers (AMs).

What the briefs combine

  • Meeting metadata (attendees, meeting title)
  • Product usage + account vitals
  • Customer intent signals (tickets, customer emails)
  • Agenda alignment to what the AM wants to do

Key technical challenge: fuzzy matching

  • The system must handle cases where the same email may map to multiple businesses.
  • It persists a mapping so downstream steps don’t recompute.

Background agent generation

Briefs are produced by an operational background agent:

  • Nightly generation
  • Per-account meeting-prep computation
  • Uses tools/skills to query the customer data layer (e.g., Postgres CDP + vector DB)

Building block #4: Skill library + extensibility across teams

A skill library allows customization of how agents generate outputs (e.g., different meeting formats).

Horizontal extension strategy

  • Create new skills
  • Add data integrations
  • Adjust which data is used (e.g., AEs may need more third-party data vs pre-sales/procurement context)

This enables reuse of the same underlying orchestration components (durable execution, retrieval, tools) while swapping skills and data.

Distribution layer: GT-MCP (shared tool access) for agent ecosystem + analytics

A “GTM MCP” is described as a window into the same tools and skills used by background agents.

  • Employees can use the same tool/skill environment that drives automation.
  • Agent developers build their own automations; their:
    • prompts
    • skills
    • instructions feed back into productionization.

This supports:

  • Productionizing successful community/employee use cases
  • Distributing them to teams with similar problems

Analytics are described as coming from reasoning/tool calls executed remotely through the MCP.

How this powers multi-channel GTM orchestration (the golf example)

An example involves offering golfers at East Coast construction companies incentives to try Ramp (e.g., Pro V1 golf balls).

The system should be able to:

  • Create a target audience
  • Generate outbound sequences and personalize copy
  • Generate paid ad + web creative (images/creative and landing pages)
  • Include in-app notifications for customers

Execution includes review/sign-off by channel owners, with the goal of accelerating safe scaling.

Guardrails + optimization framing

The orchestration balances:

  • Exploration vs exploitation (multi-armed bandit framing): try new experiments while staying safe on known returns
  • Compliance and rules of engagement: guardrails prevent unsafe/redundant behavior
  • Context awareness to avoid repeating the same actions

Guidance for smaller/newer companies (question answered)

Recommendation: start with specific automatable use cases rather than building a perfect system architecture upfront.

Example mentioned:

  • A team about 3 years prior built automated outbound using GPT-era personalization and data pulls.

After solving concrete problems, expand incrementally by piecing together vertical solutions.

Main speakers / sources

  • Arman/Armon Vaziri (Ramp) — main presenter
  • Madhu — referenced as a prior speaker (“as Madhu mentioned…”)

Original video