Intelligence Efficiency in Action: Lower Cost per Trusted Outcome with Snowflake CoCo and CoWork

Intelligence efficiency measures how effectively a company turns compute, models, data and context into business impact. The right metric is cost per outcome you can trust, not cost per attempt.

Production-grade data analysis tasks require agents to reason about business logic, handle edge cases, perform exploratory data analysis and navigate large warehouses. These sessions tend to be long, with large tool outputs that accumulate in context over many turns. As agentic workflows move into production, intelligence efficiency becomes a significant concern. A key element towards achieving intelligence efficiency in data analysis tasks is to reduce cost while maintaining quality.

Agents such as Snowflake CoCo and Snowflake CoWork can tackle deep data analysis sessions involving hundreds of model calls. In a baseline agent implementation, each call would re-read the full conversation history, reason over it and then produce output, so every token added to that history is paid for again on each turn that follows. This form of context bloat increases cost and also makes it harder for the model to attend to what actually matters, a failure mode commonly called context rot. Both pressures grow with session length, which is increasingly common in data analysis workloads. So, we set ourselves a challenge:

Could we maintain or improve CoCo and CoWork's data analysis quality while reducing token spend?

Our key findings are two-fold:

• Loading skills on demand, bundling tools dispatch and compacting tool output significantly cuts cost and raises quality. Tool schemas, skill catalogs, previous tool outputs and growing history all re-enter the prompt whether or not the current prompt/step needs them. CoCo's harness dramatically reduces the context by loading tools and skills on demand, bundling independent tool calls into a single dispatch and compacting tool output before it enters context. The savings compound: Because the harness preserves quality while cutting tokens, a smaller model on CoCo can match or beat a larger model on a conventional harness.
  • On an internal agentic SQL-fixing benchmark inspired by production workloads: CoCo on Sonnet 5 outperformed Claude Code on Opus 5 — a smaller model on the stronger harness — with success on three independent trials (Pass³) of 86% vs 72% while cost per trial fell 33% at the same time: $0.298 for CoCo on Sonnet 5 vs $0.446 for Claude Code on Opus 5.
  • The pattern holds for a broader benchmark of general Snowflake workloads. CoCo on Sonnet 5 matched the reliability of Claude Code on Opus 5 — Pass³ of 60% vs 58% while cost per trial fell 45% at the same time: $0.451 for CoCo on Sonnet 5 vs $0.821 for Claude Code on Opus 5.
• Providing semantic context upfront dramatically increases accuracy while cutting cost. The idea here is very simple: If we provide the agent necessary context that it would otherwise have to discover, it will not spend turns and tokens on discovering them at query time (for example, in scanning schemas or inferring relationships). Therefore by grounding agents in the right context provided by Cortex Sense (private preview) we expect to improve both token efficiency and accuracy. To this end, we created a set of 58 internal questions spanning Snowflake's own product analytics domain. To answer these questions correctly, the agent needs to know the right tables from within Snowflake's massive internal data estate as well as the right analytics and business context (for example, to filter out some rows and to perform the right form of aggregations).
  • We ran a simple Pass@1 evaluation comparing two systems: a) CoWork using Cortex Sense and b) Claude Code connecting to Snowflake via Snowflake MCP. We found that the former achieved 86.3% accuracy at $0.59 per query on this benchmark, compared to 24.1% accuracy at $1.76 per query for the latter — a 66% cost reduction with a 3.6× quality gain.

Let's examine these two findings in more detail.

Loading skills on demand, bundling tools dispatch and compacting tool output significantly cuts cost and raises quality

Consider the following query: Over the last 30 days, identify the most common CLI failures. Quantify their frequency and cost from warehouse telemetry, correlate relevant Slack and Jira discussions and locate the responsible code paths. Deduplicate retries and cite the evidence.

To answer this query, harnesses supplement the user prompt with tool and skill schemas: descriptions of what each tool does, sample usage patterns and the input/output shape it expects. The agent plans against this catalog, calling into warehouse telemetry, Slack and Jira, processing what comes back, and synthesizing over the accumulated context to produce a final answer.

Figure 1. A conventional agentic loop on a multi-source investigation. The full tool and skill catalog loads upfront whether or not the task needs it, and each raw result goes into model context, where it accumulates and is paid for again on every turn that follows.

When we looked closer at internal CoCo trajectories, we identified several areas for improvement.

Figure 2. Each lever in isolation: on-demand loading removes ~79k tokens of idle schema and skill context (exact savings vary by setup); Programmatic Tool Calling collapses three independent retrievals into a single round trip; offload and lossless compression hand the model a reference, not the data.

Load on demand: Only a fraction of the registered catalog is relevant to any one task. A query like this one needs a Slack search tool, a Jira search tool and a Snowflake query tool — not the other dozens of tools a general-purpose harness carries for tasks it isn't running. Loading every schema upfront means the agent pays context for tools it will never call, and the cost scales with the size of the catalog, not the size of the task. CoCo instead exposes a tool search tool: the agent describes what it needs, and the matching tool definitions are retrieved on demand instead of registered wholesale at the start of the session. Skill loading works the same way — CoCo delegates it to a dedicated sidecar that identifies the skills relevant to the current step and loads only those. Together, these mechanisms shrink the idle context window by ~79k tokens for Snowflake internal users (exact numbers vary depending on the CoCo setup for the individual) while leaving the full catalog of tools and skills available to draw on.

Bundled dispatch: Once the agent knows which tools to call, calling them one at a time wastes turns. A harness that queries Slack, then waits for the model to process the result, then queries Jira, then waits again, then queries the warehouse, pays for a full context re-read at each step even though none of the three calls depends on the others' output. Programmatic Tool Calling lets CoCo bundle independent calls, like the Slack search, Jira search, and warehouse query this task needs, into a single turn: The harness dispatches all three, collects the results and returns to the model once instead of three times.

Tool output compaction: Tool output is also processed before it enters context, rather than passed through raw. Oversized results, like a full warehouse telemetry pull or a long Jira thread, are offloaded and held as variables in a persistent Python REPL: the agent gets a reference to the data instead of the data itself, and can retrieve, filter or aggregate it later without re-reading the full payload on every subsequent turn. SQL results are losslessly compressed by exploiting the shape of the data itself (repeated column headers, predictable types, redundant formatting), preserving every value the model needs to reason over while cutting what it doesn't. What the model sees at each turn is a compact payload with pointers into the REPL, sampled and reasoned over as needed to produce the final answer, deduplicated retries and all.

Figure 3. The same investigation under CoCo. Discovery, retrieval and reduction run below the context boundary in a persistent Python REPL; one compact payload with pointers crosses into model context, and the window the baseline carried (dashed) is never built.

SQL-fixing benchmark: Combined with CoCo's inherent data analysis capabilities, the token savings let a smaller model carry the task: on our internal SQL-fixing benchmark, CoCo on Sonnet 5 beats Claude Code on Opus 5 on pass consistency (86% vs 72% Pass³) at 33% lower cost per trial ($0.298 vs $0.446). At the matched model, CoCo leads by 26 points on Opus 5 and 42 on Sonnet 5.

Troubleshooting Snowflake SQL Dataset:

Results from the internal SQL-fixing benchmark (Pass³ over three repeated trials). CoCo leads at every matched model; on Sonnet 5 it exceeds Claude Code on Opus 5 at 33% lower cost. In these runs, Claude Code on Sonnet 5 returned fixes without executing them against the warehouse — low cost per trial, but only 44% held up across repeats.

The Sonnet 5 pair is the clearest illustration of why cost per trial alone misleads. Claude Code's $0.146 attempts to fix the SQL in a single shot without checking that the fix works by running the SQL and then iterating if needed. CoCo's additional 15 cents buys execution against the warehouse and a 42-point Pass³ reliability gap. This is the sense in which intelligence efficiency is cost per outcome you can trust, not cost per attempt.

Diverse Snowflake Analytics benchmark: A separate benchmark of diverse Snowflake workloads, spanning large-scale data migrations, Streamlit analytics dashboards and more, provides similar findings. At matched model and effort, CoCo improves Pass³ by 10 points on Opus 5 (68% vs 58%) and 12 on Sonnet 5 (60% vs 48%) — and CoCo on Sonnet 5 delivers the reliability of Claude Code on Opus 5 (60% vs 58%) at 45% lower cost per trial ($0.451 vs $0.821).

General Snowflake Workloads Dataset:

Cost–quality frontier on general Snowflake workloads (Pass³ over three trials). At matched model and effort, CoCo improves reliability by 10 points on Opus 5 and 12 on Sonnet 5 over Claude Code, and CoCo on Sonnet 5 matches Claude Code on Opus 5 at 45% lower cost per trial. CoCo will be rolling out an auto model selector in order for adjustable model choice per workload in order to achieve these cost efficiency wins without user explicit control.

Because the harness shifts the whole cost–quality frontier, model and effort become a per-task choice rather than a global one: a medium-effort Sonnet 5 configuration already reaches 57% Pass³ at $0.284 per trial.

Providing semantic context upfront dramatically increases accuracy while cutting cost.

When an agent operates on undocumented data, it resorts to expensive exploration: inspecting tables, reading column metadata and inferring relationships between entities. In our experience, for most enterprises, manually curated semantic views cover roughly 5% of tables. The remaining 95% is where agents spend tokens discovering context.

Cortex Sense (private preview) is designed to reduce this by automatically building semantic understanding from signals the business already produces: past analyst queries, dbt transformations, BI metrics and governed definitions. It ranks conflicting signals by relevance, authority and freshness, surfaces unresolved conflicts to human reviewers, and continuously refreshes as the data estate evolves. This produces runtime context spanning the data estate with little to no manual curation required, working alongside semantic views, which remain authoritative for governed contexts, to cover the undocumented long tail.

On internal benchmarks, CoWork with Cortex Sense improves accuracy from 24.1% to 86.3% and reduces cost from $1.76 to $0.59 per query (a 66% reduction) compared to an ungrounded frontier agent.

Agents receive scoped, grounded context before the session begins, reducing the need to inspect tables and infer relationships at runtime. The previous section makes each task cheaper twice — fewer tokens spent on the work, and a smaller model able to do it. Cortex Sense reduces how much of that work needs to happen in the first place.

Get started

These optimizations are rolling out across CoCo and CoWork. The token-reduction and grounding levers described above work by default — the harness is designed to keep per-user spend lower without requiring manual intervention. For organizations that need explicit governance, administrators can set per-user daily credit limits across CoCo surfaces (CLI, Desktop, Snowsight) at the account or user level, and track consumption patterns through usage history views with per-request granularity by model, user and region.

Try CoCo for data engineering or CoWork for analytics.

Forward-looking statements: This article contains forward-looking statements, including about our future product offerings, and are not commitments to deliver any product offerings. Actual results and offerings may differ and are subject to known and unknown risk and uncertainties. See our latest 10-Q for more information.

¹ Much of this is on by default in CoCo today; sidecar-based skill loading and lossless result compression are coming soon to the product.

² Cost optimization features are in either private preview or public preview, depending on the applicable model. Cortex Sense is currently in private preview.