Earnings-Call Intelligence in 34 Seconds: AmpUp MCP × Snowflake Cortex Code

Snowflake  is the AI Data Cloud. The company has been clear about the bet: as AI agents take over more of the application layer, the platform holding the data those agents need becomes the most valuable piece of the stack. Recently we learned about Cortex Code  (coco), their CLI agent that runs reasoning loops directly inside the warehouse boundary. We thought: what happens if our sales-agent Model Context Protocol (MCP)  server shows up alongside sql_execute in coco’s tool catalog? The agent gets two surfaces, one for live operational data and one for analytical data, with no glue code between them.

We wired it up. In 34 seconds, coco produced five sales briefings drawn from real public-company earnings calls and drafted Slack nudges to the deal owners. Not “you have five stalled deals” but “Solstice Motors’ CEO just announced point-to-point self-driving in 2026 with 1,600 TOPS in their custom Atlas-1 silicon. Here’s what to ask in your meeting next week.”

Crucially: we never copied CRM or sales-meeting transcripts into Snowflake. AmpUp is not a CRM proxy. It is the revenue memory layer for the sales team — persistent deal, org, rep, and interaction memory that gets sharper the longer it is deployed. Each system holds what it was built for. AmpUp is the system of record for memory + comms: CRM records, meeting transcripts, emails, voice notes, and the structured memory layer built on top. Snowflake is the system of record for analytical data — your own product-usage telemetry and revenue tables, plus large-scale third-party datasets you’ve licensed (Pitchbook, Crunchbase, LinkedIn org graphs, ZoomInfo, S&P Capital IQ, the earnings-call Marketplace listing we use in this demo). Neither side belongs in the other. The agent calls both.

Locked In

• Warehouse: Snowflake  (Standard Edition, AWS Oregon for the demo)
• Agent host: Cortex Code CLI  (coco)
• Memory + comms — system of record AmpUp, queried via MCP : persistent deal/org/rep/interaction memory, plus the CRM records, sales-meeting transcripts (AmpUp’s own notetaker), emails, and voice notes the memory layer feeds on. Live, no copy, no sync.
• Analytical data — system of record Snowflake, queried via SQL: structured analytical data of every shape. Your own — product-usage telemetry, feature-adoption rollups, revenue tables. Plus licensed third-party datasets — Pitchbook, Crunchbase, LinkedIn org graphs, ZoomInfo, S&P Capital IQ, the public earnings-call Marketplace listing we use in this demo. Anything the warehouse was built for.
• Action layer: AmpUp’s MCP server. About 100 actions across CRM writes, email drafts, notetaker updates, deal-stage changes, calendar invites, Slack messages. Every action lands as a draft with full audit trail and one-click undo.

Where This Fits in Your Stack

This is not a BI dashboard. ThoughtSpot , where we worked together for 7 years (Amit was a founder and CTO; we led the AI effort from 2017–2022, both pre-LLM and post-LLM), is the agentic-analytics leader and already moves the BI category past static charts into agent-driven analysis. Your Looker , Tableau , or Sigma  dashboards tell the AE that a deal is stalled or hot. What none of them do, by design, is take action and remember. They don’t open the CRM, draft the Slack, change the stage, schedule the next meeting, then remember next quarter that this rep tends to defer scheduling to email and lose a week of velocity each time. That’s the agent’s job, and that’s where the AmpUp MCP layer sits. Cortex Code is the loop that connects “warehouse query” to “thing happens in the system of record, informed by memory of what worked before.”

Why Cortex Code Specifically

We could have wired this against any agent host. Claude Code, Cursor, Devin, a bespoke loop on top of an LLM API. Coco wins on four points that none of those share. It issues SQL as a first-class primitive, not as a bolted-on tool, so depth-of-search costs the agent nothing in plumbing. It runs inside the Snowflake security and governance boundary, which is the difference between a procurement cycle that takes a week and one that takes a quarter. It gets first-class access to Cortex AI functions (Cortex Analyst, Cortex Search, CORTEX.COMPLETE, CORTEX.EMBED_TEXT) the day they ship. And inference, storage, and warehouse compute all land on a single Snowflake invoice — one budget conversation, not three.

The Architecture in One Diagram

Two data surfaces, one agent. Memory + comms (deal/org/rep/interaction memory backed by CRM records, meeting transcripts, emails) stays live in AmpUp; analytical data — your product-usage telemetry plus the third-party datasets you’ve licensed (Pitchbook, Crunchbase, LinkedIn, earnings transcripts) — stays in Snowflake. Coco coordinates between them.

  ┌──────────────────────────┐              ┌─────────────────────────┐
  │  AmpUp                   │              │  Snowflake              │
  │  (live, via MCP)         │              │                         │
  │                          │              │  earnings transcripts   │
  │  • deal memory           │              │  (247K, public          │
  │  • org memory            │              │   companies, last       │
  │  • rep memory            │              │   ~5 years)             │
  │  • interaction memory    │              │                         │
  │    (transcripts,         │              │                         │
  │    emails, voice notes)  │              │                         │
  └──────────┬───────────────┘              └────────────┬────────────┘
             │                                           │
             │ MCP tool calls                            │ sql_execute
             │ (list_opportunities,                      │
             │  email_draft, ...)                        │
             ▼                                           ▼
  ┌──────────────────────────────────────────────────────────────────┐
  │            coco  (Cortex Code CLI, in-warehouse agent)           │
  └──────────────────────────────────────────────────────────────────┘

No hydration step. No AMPUP_DEMO schema mirror. The CRM, the memory layer, and meeting transcripts are queried live every time the agent needs them, the same way an AE would refresh their dashboard before a call. The warehouse handles what only the warehouse can handle: large-scale structured analytical data. In this demo, 247K earnings transcripts spanning ~2.9M public companies. In your stack, this is also where product-usage telemetry, feature-adoption rollups, revenue tables, and licensed third-party datasets (Pitchbook, Crunchbase, LinkedIn, ZoomInfo, S&P Capital IQ) live — none of which belong in the CRM.

What’s in the Warehouse

The earnings-call dataset, sitting in Snowflake, contains 247,383 speaker-annotated transcripts from public-company events: quarterly calls, investor days, AGMs, capital markets days. Each transcript is structured JSON. Paragraphs tagged with speaker IDs, fiscal period, event type, timestamp. Joinable to companies by ticker, CIK , or company name.

SELECT EVENT_TITLE, EVENT_TIMESTAMP,
       transcript:paragraphs[10]:text::STRING AS sample
FROM   COMPANY_EVENT_TRANSCRIPT_ATTRIBUTES
WHERE  PRIMARY_TICKER = 'SLST'
ORDER BY EVENT_TIMESTAMP DESC
LIMIT 1;

Five rows back. Solstice Motors’ most recent event was their AI and Autonomy Day, December 2025, with the CEO walking through Atlas-1 silicon and Gen 3 platform timing. The kind of context an AE would normally spend an hour assembling.

Today we read this dataset via raw SQL because it keeps the demo legible. In production, this is the kind of analytical surface that gets indexed by Cortex Search  (over the unstructured transcript text), semantically modeled by Cortex Analyst , and summarized inline by CORTEX.COMPLETE. Coco picks the right tool per question.

What’s in AmpUp (the Part That Makes the Briefings Actually Good)

The warehouse side is impressive but generic: same earnings call, same transcript, available to anyone with a Snowflake account. The AmpUp side is what makes the output specific to this AE and this deal.

When the agent asks AmpUp for context, it doesn’t get a CRM dump. It gets memory, in four recognizable shapes:

• Deal memory. Per-field provenance, confidence, staleness. Not just “champion identified” but “this contact has not introduced a budget owner, has not shared internal documents, has not spent political capital across two calls. Treat as possible coach, not confirmed champion.”
• Org memory. Validated winning patterns and anti-patterns across the team’s deals, replay-tested with evidence counts. OM-COMMITMENT-SLIP: champion fails to deliver committed artifact, evidence from 14 deals, win rate drops to 22%. New reps inherit the team’s selling intelligence on day one.
• Rep memory. Per-rep behavioral profile measured against outcomes. “Alex defers scheduling to email on 4 of 6 calls; deal velocity drops 35%.” The agent knows what this rep tends to miss and prompts accordingly.
• Interaction memory. Transcripts, emails, voice notes, structured into citation-bearing claims with provenance. 1,000 pages of transcript compressed to a few KB of structured memory the agent can actually reason over.

These four memory shapes flow through the MCP tools the agent already knows about (list_opportunities, get_account, email_draft, …). When coco fetches a deal, the response is deal memory — not a CRM record. Memory isn’t a separate API surface; it’s what AmpUp returns instead of records.

Most sales AI starts from zero on every call. AmpUp’s memory compounds: every deal outcome reinforces what works, every contradiction retracts gracefully, every commitment is tracked across calls — so the agent knows that “Priya committed to the architecture doc twice and delivered zero times” before it drafts the next follow-up.

This is the layer that turns a generic earnings-call summary into a briefing that says “lead with autonomy talking points, not renewal mechanics, because the deal owner tends to default to renewal framing and this CFO just told the market AI is core capital allocation.”

Wiring Cortex Code to AmpUp’s MCP Server

One-time configuration. Cortex Code reads ~/.snowflake/connections.toml for warehouse access and ~/.snowflake/cortex/mcp.json for MCP servers:

cortex mcp add ampup-staging \
  https://ampup.staging.a79dev.com/mcp/sse \
  -t http \
  -H "Authorization: Bearer $AMPUP_API_KEY"

That’s it. Every MCP tool we expose appears in coco’s catalog alongside sql_execute and the rest of Cortex Code’s native tool set.

The Prompt

What an AE would actually type. No schema names, no paragraph numbers, no SQL hints. Just the goal:

$ cortex -c coco

> I have demos lined up next week with our top public-company
  prospects. Pull my open deals from AmpUp, find the most recent
  earnings call for each company, and tell me the most interesting
  thing each CEO said about strategy. Then draft a Slack message to
  the deal owner for each one. Don't actually send anything.

Coco figures out the rest: which MCP tool gives it the deal list, how to map account names to public-company tickers, which Snowflake table holds the transcripts, and which MCP tool drafts the message.

What Coco Did (the Tool Sequence)

The interesting part. Each tool_use is coco picking from its catalog (Snowflake’s native sql_execute plus AmpUp’s MCP tools) on its own:

[1]  TOOL_USE  mcp__ampup-staging__list_opportunities
       input: {"limit": 10, "stage": "open"}
[2]  RESULT    [{ name: "Solstice Motors Services", account_name: "Solstice Motors",
                  amount: 365000, owner_name: "Connor R", id: "30986…" },
                { name: "Avionix Aviation — AEA 2026", … },
                … 5 deals total ]

[3]  TEXT      "I'll find tickers for these companies in the warehouse."
[4]  TOOL_USE  sql_execute
       sql:  SELECT COMPANY_NAME, PRIMARY_TICKER
             FROM COMPANY_INDEX
             WHERE PRIMARY_TICKER IS NOT NULL
               AND (COMPANY_NAME ILIKE 'Solstice Motors%'
                 OR COMPANY_NAME ILIKE 'Avionix%'
                 OR COMPANY_NAME ILIKE 'Ridepoint%'
                 OR COMPANY_NAME ILIKE 'Lumagate%'
                 OR COMPANY_NAME ILIKE 'Threadworks%')
[5]  RESULT    SOLSTICE MOTORS INC → SLST │ AVIONIX GROUP → AVXC │ … 5 matches

[6]  TEXT      "Pulling the most recent earnings call for each."
[7]  TOOL_USE  sql_execute
       sql:  SELECT PRIMARY_TICKER, EVENT_TITLE, EVENT_TIMESTAMP, TRANSCRIPT
             FROM COMPANY_EVENT_TRANSCRIPT_ATTRIBUTES
             WHERE PRIMARY_TICKER IN ('SLST','AVXC','RDPT','LMGT','TWRX')
             QUALIFY ROW_NUMBER() OVER (
                       PARTITION BY PRIMARY_TICKER
                       ORDER BY EVENT_TIMESTAMP DESC) = 1
[8]  RESULT    [5 transcripts: 'AI and Autonomy Day' (SLST), 'Q3 2025' (AVXC), …]

… reasoning over each transcript …

[9]  TOOL_USE  mcp__ampup-staging__email_draft  (×5, one per deal)
       input: { opportunity_id: "30986…",
                additional_context: "Solstice CEO announced point-to-point
                self-driving in 2026 with 1,600 TOPS Atlas-1 silicon;
                they're scaling AI infrastructure aggressively. AE should
                lead with autonomy talking points, not renewal mechanics." }
[10] RESULT    { id: "1bc0b984-…", subject: "Solstice Motors Services next steps",
                 body: "I've been thinking about the Services deal…",
                 status: "draft" }

[…] DONE       33.8s, 7 turns, 307K input tokens, 526 output

We didn’t write any orchestration. The prompt described the goal and coco wired the calls: live memory + CRM via MCP, analytical context via SQL, action layer via MCP again. Three round trips between the two systems and we get five drafts.

The Drafts

Five public-company deals, five briefings, five quotes pulled from real earnings calls in the past four months:

Deal	Source	Coco’s sales angle
Solstice Motors, $365K	AI and Autonomy Day, Dec 2025	Building in-house Atlas-1 AI silicon. Gen 3 platform with 1,600 TOPS late 2026. Point-to-point self-driving rolling out 2026. They will buy AI infrastructure at scale.
Avionix Aviation, $262K	Q3 2025, Oct 2025	Aviation segment +18% YoY. Certified auto-land on a twin-engine turboprop. Raising aviation guidance to 10%. Heavy avionics-cert investment.
Ridepoint, $185K	Q4 2025, Feb 2026	CFO transition Feb 16 (Devon, Mira). New CFO will re-evaluate vendor relationships. Land before transition.
Threadworks, $50K	AGM Jan 2026	Company nearly 4בd from $5B to $20B. Growth doubled to 16%. Declared AI/data as core capital allocation 7 years ago. $300B TAM, 6% penetration.
Lumagate Networks, $150K	Q2 FY26, Jan 2026	NSE rev +46% YoY. Data-center ecosystem now 45% of mix. 5% workforce restructuring with $30M annual savings redirected to growth.

Notice the specificity. Coco didn’t paraphrase a “headcount up” or “AI strategy” generic. It pulled actual numbers and program names out of unstructured speaker-annotated text, then crossed them with what AmpUp’s memory layer knew about each deal: stage, owner, history of objections, and the rep’s tendencies.

Sample draft (verbatim, what the AE would receive in their AmpUp Tasks inbox):

SUBJECT: Solstice Motors Services next steps
BODY:    I've been thinking about the Services deal and how we can
         best support the team's training roll-out. Given the scope
         of the automotive industry rollout, I've got a couple ideas
         on how we can streamline the roleplay practice for your reps.

         Are you free for a quick phone call tomorrow afternoon?
         I'd like to hash out the final details so we can get this
         moving toward the finish line.

         Best,
         Rahul Balakavi

5 drafts created in ~34 seconds end-to-end. Cost: ~$0.10 in Cortex Code  inference credits.

What We Took Away

The “warehouse + agent + MCP + memory” stack is real. Each layer is cleanly substitutable. Snowflake is the most credible substrate to build it on: security boundary, governance plane, scale story all already in place for the data team. Cortex Code is the right loop. MCP is the right protocol. And the agent is only as good as the memory it can reach.

Comms data should not move; memory has to live somewhere. Sales conversations, CRM records, emails, voice notes — these belong in AmpUp and stay there, queried live via MCP. The memory layer (deal/org/rep/interaction) is built on top: deduped across hundreds of calls per account, with provenance preserved and stale claims retracted gracefully as new evidence arrives. Comms data needs that featurization step — concept extraction, grounded excerpts, rep-level rollups — and the warehouse was not built for it. Trying to land transcripts in Snowflake on the way to an agent is a step backwards: you lose freshness, lose grounding, and gain a sync job. Pre-extracted features can flow out of AmpUp into a Snowflake share for cross-domain analytics if a team wants that — but the system-of-record stays in AmpUp.

Two transcript surfaces, two purposes. The earnings-call transcripts come from Snowflake (public-company data, large scale, analytical). The sales-meeting transcripts come from AmpUp’s notetaker (your own customer conversations, operational, action-oriented, and folded into the memory layer). Coco joins them through the same agent loop, but the data never gets confused: warehouse for public, MCP for private.

MCP is the right shape for the action layer, at scale. AmpUp’s MCP server exposes ~100 actions today: CRM writes, email drafts, notetaker updates, deal-stage changes, task creation, calendar invites, Slack messages, contact merges. The email_draft tool we showed above is one example. Every action lands as a draft with full audit trail and one-click undo. The agent never silently mutates a system of record; the user always reviews before the change ships. That’s what makes “the warehouse takes action” safe to ship to a sales org.

The prompt doesn’t need to be smart, the data and the memory do. Our prompt was three sentences. The earnings calls did the public-side heavy lifting. The memory layer did the private-side heavy lifting: which deal this is, who owns it, what’s been promised, what this rep tends to miss. The agent’s job was to route between the two surfaces.

The value compounds, on both sides of the wire. A typical AE spends 30 minutes prepping for a single discovery call: pulling the company’s recent news, last earnings call, hiring trends, a quote to open with. Doing this for 5 deals: 2.5 hours per AE per week. For a 20-AE team: 50 hours weekly that goes to prep instead of selling. Coco does the same prep in 34 seconds at ~$0.10 per deal. That’s the easy savings. The harder, more interesting compounding happens on the AmpUp side: every meeting, every objection handled, every commitment kept or missed gets folded back into org and rep memory, validated against outcomes, replay-tested against historical deals before being promoted to a pattern. Your competitor’s AI does the same thing on day 100 that it did on day 1. A memory system gets sharper.

Coming Next: When the Agent Picks Its Own SQL

A natural follow-up: how much of the output quality came from coco’s autonomous tool use specifically, vs. just having an LLM in the loop? In our next post we ran the same workflow through a hand-coded Python orchestration loop. Same Snowflake data, same AmpUp MCP, same underlying frontier model. Coco’s sales angles had 4× more specific numbers per deal, and on Threadworks’ AGM transcript the hand-coded loop gave up where coco found the strongest quote in the deck. We dig into why.

Try It

If you’re a Snowflake customer and want this against your own pipeline data: ping us at [email protected]. We’re rolling out the AmpUp MCP server as a Snowflake Native App . The install is one click and runs entirely inside your Snowflake account.

If you’re at Snowflake and want to dig into Cortex Analyst  (semantic models on top of these views), Cortex Search  (over the unstructured public-event text), or Native App distribution: same address. We think this pattern — agent-driven warehouse queries hitting an open-protocol action layer backed by a real revenue memory system, with the CRM staying live in its system of record — is the next thing every B2B SaaS company will want, and we’d like to do it together.