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

Snowflake  is a leader in analytics. It’s the warehouse underneath thousands of B2B teams. 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 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 “Helios 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 data into Snowflake. The CRM stays in its system of record (AmpUp), accessed live via MCP. The warehouse holds what only the warehouse should hold: large-scale analytical data the CRM was never designed to store.

Locked In

• Warehouse: Snowflake  (Standard Edition, AWS Oregon for the demo)
• Agent host: Cortex Code CLI  (coco)
• Live CRM and meeting data: AmpUp via MCP . The CRM stays in its system of record. AmpUp’s own notetaker captures meeting recordings and transcripts. Both are queried live, no copy, no sync.
• Analytical data: 247K public-company earnings calls, queried in place inside Snowflake
• 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. Your Looker , Tableau , ThoughtSpot , or Sigma  dashboards already tell the AE that a deal is stalled or hot. What they don’t do is take action. They don’t open the CRM, draft the Slack, change the stage, schedule the next meeting. 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.”

The Architecture in One Diagram

Two data surfaces, one agent. CRM stays live in AmpUp; Snowflake holds the analytical data the warehouse was built for. Coco coordinates between them.

  ┌──────────────────────┐                  ┌─────────────────────────┐
  │  AmpUp CRM           │                  │  Snowflake              │
  │  (live, via MCP:     │                  │                         │
  │   accounts, deals,   │                  │  earnings transcripts   │
  │   contacts, tasks)   │                  │  (247K, public          │
  └──────────┬───────────┘                  │   companies, last       │
             │                              │   ~5 years)             │
             │ MCP tool calls               └────────────┬────────────┘
             │ (list_opportunities,                      │
             │  email_draft, ...)                │ sql_execute
             ▼                                           ▼
  ┌──────────────────────────────────────────────────────────────────┐
  │            coco  (Cortex Code CLI, in-warehouse agent)           │
  └──────────────────────────────────────────────────────────────────┘

No hydration step. No AMPUP_DEMO schema mirror. The CRM is queried live every time the agent needs it, the same way an AE would refresh their dashboard before a call. The warehouse handles what only the warehouse can handle: 247K earnings transcripts spanning ~2.9M public companies, going back five years, none of which belong in a 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 = 'HMOT'
ORDER BY EVENT_TIMESTAMP DESC
LIMIT 1;

Five rows back. Helios 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.

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: "Helios Motors Services", account_name: "Helios 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 'Helios Motors%'
                 OR COMPANY_NAME ILIKE 'Avionix%'
                 OR COMPANY_NAME ILIKE 'Ridepoint%'
                 OR COMPANY_NAME ILIKE 'Lumagate%'
                 OR COMPANY_NAME ILIKE 'Threadworks%')
[5]  RESULT    HELIOS MOTORS INC → HMOT │ 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 ('HMOT','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' (HMOT), '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: "Helios 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: "Helios 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 CRM data 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
Helios 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.

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

SUBJECT: Helios 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” 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.

CRM data should not move (unless you want it to). The CRM is the system of record for accounts, deals, contacts, and tasks. AmpUp’s notetaker holds the meeting recordings and transcripts. Both stay live, queried via MCP, no duplicate state and no sync lag. That said, AmpUp can also cache CRM and notetaker data into Snowflake on request, for teams that want everything in one place for cross-domain analytics. The architecture works equally well with or without the warehouse holding a copy.

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). 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 does. Our prompt was three sentences. All the intelligence came from the earnings calls. The agent’s job was to route between the two surfaces; the data did the heavy lifting.

Where the value compounds. 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. Doing it 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. The warehouse is paying for itself in AE time before the agent even closes a deal.

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 rahulb@ampup.ai. 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 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.