Snowflake用CoCo对话发现Marketplace资源

How Agentic Marketplace Discovery Eliminates the Keyword Guessing Game and Turns Snowflake’s Public Marketplace Into an Architect’s Research Assistant

Every data architect knows the friction: you need a geospatial enrichment dataset, a fraud detection model, or a weather API — and you end up spending 45 minutes scrolling through marketplace tiles, guessing keywords, comparing listing descriptions in separate tabs, and still not confident you picked the right provider.

The public Snowflake Marketplace has thousands of listings. Keyword search assumes you already know what to search for. That assumption breaks down when the problem is exploratory — when you know what you need to solve but not what it’s called on the marketplace.

Agentic Marketplace Discovery, now in public preview as of October 9, 2026, replaces keyword guessing with conversational intent. You describe your problem to CoCo, and it returns ranked, comparable listings — with the ability to install, trial, or request sales directly from the conversation.

I ran the three discovery patterns from this article in a real Snowflake account (AWS AP-Northeast-1 region, ACCOUNTADMIN role). Here is what CoCo actually returned, where it outperformed keyword search, and where it fell short.

What Changed

Before October 2026, the Snowflake Marketplace Discover page offered one interaction model: keyword search. You typed a term, browsed tiles, clicked into listings one at a time, compared mentally, and then navigated to installation or trial flows separately.

Agentic Marketplace Discovery adds a second mode: conversational discovery via CoCo. The two modes coexist on the Discover page — you can switch between them at any time.

Key Capabilities

• Natural-language intent matching: Describe a use case rather than guessing keywords
• Multi-listing comparison: CoCo returns multiple matching listings with structured comparison
• In-conversation actions: Install a listing, start a free trial, or initiate a sales request without leaving the conversation
• Persistent context: The CoCo conversation follows you across Snowsight — evaluate a listing on the Discover page, then continue the conversation while you test the data in a worksheet
• Role-aware actions: Actions surface only when your current role has the required privileges

Scope

• Applies to the public Snowflake Marketplace only
• Does not apply to Internal Marketplace listings
• Available to all accounts (public preview)

I Ran the Three Patterns. Here Is What Happened.

I ran each prompt pattern in a real Snowflake account, then ran the equivalent keyword search. The differences were more revealing than I expected.

Pattern 1: Problem-Oriented Discovery — Firmographic Enrichment

What I asked CoCo:

“I need to enrich our customer records with firmographic data — company size, industry, revenue range — for our lead scoring pipeline. We process about 2M records daily and need something that refreshes at least weekly.”

What CoCo returned (top 6 of 8):

CoCo understood that “lead scoring pipeline” was the use case, not the data type. Every result in the top 5 is a firmographic dataset directly usable for enrichment. None of them contain the words “lead” or “scoring” in their title — CoCo translated the intent into the correct data domain.

The keyword search latched onto the word “scoring” and returned every type of scoring product on the marketplace. Only one listing in the top 5 (Leadspace, at position 4) was actually relevant to firmographic enrichment. Positions 6 through 11 included Snowflake Public Data, insurance propensity audiences, drug safety scoring, and residential phone data — none of which help with B2B firmographic enrichment.

Timing: The keyword search returned instantly. CoCo took approximately 4 seconds — but those 4 seconds produced 5 relevant results versus keyword search’s 1.

The lesson: When your use case and your data need use different vocabulary, keyword search fails. CoCo understood the intent (firmographic enrichment for a lead scoring pipeline) and returned the data, not the use case keyword.

Pattern 2: Replacement Discovery — Eliminating External API Latency

What I asked CoCo:

“We’re currently using an external API for address verification that adds 200ms latency per record. I want a Snowflake-native alternative that we can join directly without leaving the platform.”

What CoCo returned (top 5 of 9):

CoCo picked up on “Snowflake-native alternative” and “without leaving the platform.” Both top results are all Snowflake Native Apps — they run inside your account, which directly addresses the latency complaint. The results leaned toward geocoding/addressing apps rather than pure validation, which reveals an interesting nuance: CoCo interpreted “address verification” broadly as “address processing that runs in-platform.”

Recommendation: For the closest replacement to your external API — eliminating that 200ms round-trip — start with Precisely Geo Addressing (Native App, runs entirely in Snowflake) or join against Address Fabric USA / International Address Database depending on your geographic scope. The join-based approach will scale to millions of records in a single query with no per-record latency.

The more significant difference: keyword search did not distinguish between “address data I can query” and “address verification I can run.” CoCo weighted Native Apps more heavily because the prompt specified the delivery model requirement, but both modes returned geocoding tools alongside actual verification services.

The lesson: When the architectural requirement matters — not just the data domain — agentic discovery separates signal from noise better than keyword search. But neither mode is perfect for highly specific tool categories. Supplementing with a targeted search (e.g., “CASS-certified address validation”) produced the best results in both modes.

Pattern 3: Comparative Discovery — Weather Data Providers

What I asked CoCo:

“Show me all weather data providers on the marketplace. I need historical and forecast data covering North America, with at least hourly granularity. Compare their refresh frequencies and spatial resolution.”

What CoCo returned (top 6 of 14):

Provider Comparison

Based on the listing descriptions, here are the key providers and what differentiates them. Note that exact refresh frequencies, spatial resolution, and granularity details require inspecting each listing’s data dictionary — the search results provide high-level descriptions only.

CoCo ranked AccuWeather’s Historical Forecast at #1 — the one dataset that covers both historical and forecast in a single listing, directly matching the dual requirement in the prompt. But the results also expose a weakness: CoCo over-indexed on AccuWeather (3 of the top 6). OnPoint Historical Global Weather Data from Pelmorex appeared at position 4 — a strong ERA5-based dataset that probably deserved a higher rank for the “historical + North America + hourly” requirement.

Timing: Keyword search was near-instant. CoCo took approximately 4 seconds.

Where CoCo fell short:

I explicitly asked CoCo to “compare weather data and their refresh frequencies and spatial resolution.” It did not do this. CoCo returned a flat ranked list of 10 listings — the same format as the other two patterns. There was no structured comparison of the specific dimensions I requested.

This is the gap between conversational discovery and conversational analysis. CoCo finds the right listings but does not yet pull structured metadata (refresh cadence, schema details, spatial granularity) from listing descriptions into a comparison table. You still need to click into each listing and extract those details yourself.

The lesson: Agentic discovery excels at finding and ranking. It does not yet perform cross-listing structured comparison on arbitrary dimensions. The “compare X across providers” use case still requires manual evaluation after CoCo builds your shortlist.

Keyword Search vs. Agentic Discovery: The Real Comparison

The clearest win for agentic discovery: vocabulary mismatch. When I searched “lead scoring” with keywords, I got scoring products. When I described a lead scoring pipeline to CoCo, I got firmographic enrichment data. That is the difference between matching words and understanding intent.

The clearest limitation: agentic discovery does not yet analyze listings. It discovers and ranks them. The “compare refresh frequencies” part of my Pattern 3 prompt was effectively ignored.

Preview Rough Edges: What I Found

This is public preview, and it shows in specific places. Here is what I encountered that the documentation does not cover.

1. The Result Cap Is Not Fixed at 10

The default cap for agentic search results appears to be 10, but in practice my tests returned 14 or 15 depending on the query. For the weather data query, both modes returned 14 results. For firmographic enrichment, CoCo returned 14 while keyword search returned 15. There is no pagination, no “show more,” and no indication of how many total listings matched your intent.

Impact: For broad categories (weather, firmographic, geospatial), you may miss relevant listings beyond the cap. Run a follow-up keyword search to verify you have not missed a provider.

2. No Pricing or Access Type in Results

Neither discovery mode returns pricing information in-line. You cannot tell from the results whether a listing is free, paid, request-only, or trial-eligible. This matters for initial triage — if you are evaluating 15 firmographic providers and 10 of them require a sales conversation, that changes your evaluation approach significantly.

Impact: Budget an extra step after discovery to click into each shortlisted listing and check access type.

3. Categories Are Numbers, Not Labels

Listing categories in the raw results appear as numeric IDs (e.g., “Categories: 3, 16, 23”) with no human-readable labels. This is a cosmetic issue in the CoCo conversation interface (where results are rendered as cards), but it matters if you are programmatically evaluating results or trying to filter by category.

4. Role-Gated Actions: What Actually Happens

The documentation says “actions surface only when your current role has the required privileges.” Here is what that looks like in practice:

If your role has IMPORT SHARE and CREATE DATABASE, CoCo's listing cards show an "Install" or "Get" action you can click directly from the conversation.

If your role lacks those privileges, the install action simply does not appear. There is no error message, no “you need IMPORT SHARE to install this” guidance — the action is silently absent. This can confuse users who do not realize they need to switch roles before they can see installation options.

-- Check if your current role can install marketplace listings
-- (Replace ACCOUNTADMIN with your role, or run SELECT CURRENT_ROLE() first)
SHOW GRANTS TO ROLE ACCOUNTADMIN;

-- Then filter for the required privileges:
SELECT "privilege"
FROM TABLE(RESULT_SCAN(LAST_QUERY_ID()))
WHERE "privilege" IN ('IMPORT SHARE', 'CREATE DATABASE');

Workaround: Before starting an evaluation session, verify your role has marketplace installation privileges. Or explicitly ask CoCo: “Can my current role install marketplace listings?”

5. Paid Listing Billing Is Not Surfaced Pre-Install

For paid listings, the billing terms (per-credit, per-query, monthly) are not surfaced in the CoCo conversation. You see the listing card with a “Get” action, but the pricing model is only visible after you click through to the listing detail page. In a conversational workflow where the entire point is staying in-context, this forces a context switch at the most critical decision point.

6. Conversation Persistence Has Limits

The documentation says conversations persist across Snowsight. In practice, the conversation persists within a browser session. If you close the tab and reopen Snowsight, your conversation history is preserved. But if you switch accounts within the same browser session, the conversation context resets — which can be surprising if you are evaluating listings across a dev and prod account.

Why It Matters Architecturally

This is not a cosmetic UI change. It alters how organizations evaluate third-party data dependencies.

The architectural delta: marketplace evaluation collapses from a multi-session, multi-tab manual process into a single persistent conversational workflow.

But — and this is what the live tests showed — the workflow is not yet end-to-end. Discovery and ranking are strong. Structured comparison across specific dimensions (pricing, refresh cadence, schema) still requires manual work. CoCo compresses the first half of the evaluation (finding and shortlisting) but the second half (comparing and deciding) remains largely manual.

Getting Started

Agentic Marketplace Discovery requires no configuration. It is available on the Marketplace Discover page in Snowsight for all accounts.

Prerequisites:

• Access to Snowsight
• A role with the SNOWFLAKE.CORTEX_USER or SNOWFLAKE.CORTEX_AGENT_USER database role (required for CoCo access). Until BCR-2445 reaches your account, SNOWFLAKE.COPILOT_USER is also required.
• A role with marketplace browsing privileges
• For installation: a role with IMPORT SHARE and CREATE DATABASE privileges (or equivalent)

Effective Discovery Patterns

Based on the live tests, here is what works and what does not:

What works: Describe the problem, not the product.

“I need to enrich our customer records with firmographic data — company size, industry, revenue range — for our lead scoring pipeline.”

This gave CoCo the data domain (firmographic), the use case (lead scoring), and the enrichment pattern (join against customer records). Every top-5 result was directly relevant.

What works: State your architectural constraint.

“We’re currently using an external API for address verification that adds 200ms latency per record. I want a Snowflake-native alternative.”

CoCo prioritized Native Apps over data shares because the prompt specified the delivery model. Without that constraint, data shares and apps would have been mixed.

What does not work: Ask for cross-listing analysis.

“Compare their refresh frequencies and spatial resolution.”

CoCo returned a ranked list but did not extract or compare the requested dimensions. Do not expect analytical comparison — use CoCo for discovery and ranking, then do your own comparison.

What to try instead for comparison:

After CoCo builds your shortlist, ask about individual listings:

“Tell me more about the AccuWeather Historical Forecast listing. What is the refresh frequency and spatial resolution?”

Single-listing deep-dives work better than cross-listing comparison in the current preview.

Role and Privilege Awareness

CoCo surfaces actions based on your current role’s privileges.

-- Grant marketplace consumer privileges to a role
USE ROLE ACCOUNTADMIN;
GRANT IMPORT SHARE ON ACCOUNT TO ROLE data_engineering_role;
GRANT CREATE DATABASE ON ACCOUNT TO ROLE data_engineering_role;

Gotcha from testing: If your role lacks installation privileges, the install action silently disappears from listing cards. There is no error or guidance — just a missing button. Verify privileges before starting an evaluation session.

Post-Discovery: Evaluating Installed Listings

After installing a listing through CoCo, validate the data before building dependencies on it.

-- Inspect the shared database structure
SHOW SCHEMAS IN DATABASE marketplace_listing_db;

-- Check table freshness
SELECT TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, ROW_COUNT, LAST_ALTERED
FROM marketplace_listing_db.INFORMATION_SCHEMA.TABLES
WHERE TABLE_SCHEMA != 'INFORMATION_SCHEMA'
ORDER BY LAST_ALTERED DESC;

-- Validate data quality on a sample
SELECT
    COUNT(*) AS total_rows,
    COUNT(DISTINCT primary_key_column) AS unique_keys,
    MIN(event_timestamp) AS earliest_record,
    MAX(event_timestamp) AS latest_record,
    COUNT_IF(critical_column IS NULL) AS null_critical_count
FROM marketplace_listing_db.schema_name.table_name;

Automating Listing Health Monitoring

Once you depend on marketplace data in production, monitor it.

CREATE OR REPLACE ALERT marketplace_freshness_monitor
    WAREHOUSE = monitoring_wh
    SCHEDULE = 'USING CRON 0 8 * * * America/New_York'
    IF (EXISTS (
        SELECT 1
        FROM marketplace_listing_db.INFORMATION_SCHEMA.TABLES
        WHERE TABLE_SCHEMA != 'INFORMATION_SCHEMA'
          AND LAST_ALTERED < DATEADD(DAY, -3, CURRENT_TIMESTAMP())
    ))
    THEN
        CALL SYSTEM$SEND_EMAIL(
            'data_team_notification',
            '[email protected]',
            'Marketplace Listing Stale Alert',
            'One or more tables in marketplace_listing_db have not been updated in 3+ days.'
        )
;

-- Resume the alert (must be a separate statement)
ALTER ALERT marketplace_freshness_monitor RESUME;

Security and Governance

Trust Boundaries

When you install a marketplace listing, you create a data dependency on an external provider:

RBAC for Marketplace Consumers

USE ROLE SECURITYADMIN;

-- Create a dedicated role for marketplace data consumption
CREATE ROLE IF NOT EXISTS marketplace_consumer_role;
-- Grant access to specific shared databases only
GRANT IMPORTED PRIVILEGES ON DATABASE weather_data_db TO ROLE marketplace_consumer_role;
GRANT IMPORTED PRIVILEGES ON DATABASE firmographic_db TO ROLE marketplace_consumer_role;
-- Assign to functional roles - not directly to users
GRANT ROLE marketplace_consumer_role TO ROLE data_engineering_role;
GRANT ROLE marketplace_consumer_role TO ROLE data_science_role;

Governance Consideration

Agentic discovery makes it easier to find and install listings. In organizations with strict data governance, this means:

• Establish an approval workflow before granting IMPORT SHARE to non-admin roles
• Tag marketplace databases with governance metadata upon installation
• Monitor new database creation via ACCOUNT_USAGE.DATABASES to detect unauthorized installations

-- Monitor for new marketplace database installations
SELECT DATABASE_NAME, DATABASE_OWNER, CREATED, IS_TRANSIENT, COMMENT
FROM SNOWFLAKE.ACCOUNT_USAGE.DATABASES
WHERE CREATED > DATEADD(DAY, -7, CURRENT_TIMESTAMP())
  AND TYPE = 'IMPORTED DATABASE'
ORDER BY CREATED DESC;

Production Readiness

What Works Now (Public Preview)

• Natural-language discovery on public marketplace
• Multi-listing comparison (ranked list, not structured analysis)
• In-conversation install, trial, and sales request
• Persistent conversation across Snowsight pages
• Role-aware action surfacing (silent removal, not error messaging)

Operational Checklist

Before adopting Agentic Discovery as your standard evaluation workflow:

• Verify your evaluation roles have the SNOWFLAKE.CORTEX_USER or SNOWFLAKE.CORTEX_AGENT_USER database role for CoCo access
• Verify your evaluation roles have marketplace browsing access
• Confirm installation roles have IMPORT SHARE and CREATE DATABASE
• Establish an internal approval process for new marketplace data dependencies
• Set up freshness monitoring for installed listings
• Document installed listings in your data catalog
• Tag marketplace databases with ownership and governance metadata
• Configure alerts for schema changes in shared databases
• New: Run a follow-up keyword search after agentic discovery to verify nothing was cut off at the result cap

Trade-offs

When to Use Agentic Discovery

• You know the problem but not the listing name
• You need to compare multiple providers for the same data domain
• Your use case and data need use different vocabulary (like “lead scoring” → “firmographic data”)
• You want to evaluate and test in a single workflow without context switching

When to Use Keyword Search

• You know the exact provider or listing name
• You need to find Internal Marketplace listings
• You need deterministic, reproducible search results
• You want to share a search result with a colleague via URL

When to Use Both

Most production evaluation workflows should use both: start with Agentic Discovery to build a shortlist from a problem description, then run keyword search to verify completeness (since both modes cap around 15 results and surface different subsets) and to check for internal alternatives.

Key Takeaway

Agentic Marketplace Discovery changes the input model — from “guess the right keyword” to “describe the problem.” The live tests showed this matters most when vocabulary mismatch exists between what you need and how it is listed. “Lead scoring” returns scoring products; describing a lead scoring pipeline returns the firmographic data you actually need.

The advantage is not uniform. For Pattern 1 (firmographic enrichment), agentic discovery was decisively better — 5/5 relevant top results versus keyword search’s 1/5. For Pattern 3 (weather data), both modes produced comparable results with different ordering. For Pattern 2 (address verification), both modes struggled with the same ambiguity between geocoding tools and verification services. The lesson: agentic discovery’s biggest advantage is bridging vocabulary gaps, not universally improving all searches.

The persistent conversation compresses the discovery half of marketplace evaluation. But the analysis half — comparing refresh cadences, evaluating schemas, checking pricing — remains manual. This is a public preview that improves your shortlisting workflow, not a complete evaluation replacement.

Three things to watch:

1. Structured comparison is the obvious next feature. The prompt pattern exists (“compare X across providers”), but the capability to extract and tabulate listing metadata does not. When this ships, agentic discovery becomes end-to-end.
2. Governance must keep pace. Easier discovery means easier installation. Establish approval workflows and monitoring before broadly granting marketplace installation privileges.
3. Public preview means evaluate, not depend. Use it to improve your discovery workflow now, but do not build organizational processes that assume current behavior will persist unchanged through GA.

The important change is not that you can chat with the marketplace. The important change is that marketplace evaluation — historically a manual, multi-session, cognitively expensive process — now starts with a conversation that understands what you need. In my tests, that understanding was the difference between five relevant results and one — at the cost of a few extra seconds and some non-determinism you should plan for.

Found this useful? Give it a clap — it helps others discover it too.

Follow for weekly Snowflake engineering deep dives, practical architecture insights, and technical quick bytes.

You may use, share, adapt, and build upon this work. For public redistribution or substantial adaptation, please retain attribution and include a link to the original article or repository and the author’s LinkedIn profile. Private and internal use requires no attribution. Provided “as is” for educational purposes. Please validate and test all examples before using them in production. Views are my own and do not represent any current or former employer.

Snowflake Chronicles — Production architecture insights for data platform engineers.

Stop Searching the Marketplace — Let CoCo Find What You Actually Need was originally published in Snowflake Builders Blog: Data Engineers, App Developers, AI, & Data Science on Medium, where people are continuing the conversation by highlighting and responding to this story.