DEV Community: Oskar

FinOps X 2026 recap: the great token panic

Oskar — Mon, 15 Jun 2026 07:25:27 +0000

If you were following the FinOps X 2026 conference that just wrapped up in San Diego (June 8–11, 2026), you probably noticed a massive shift. The discipline has officially outgrown its cloud-cost-management origins. While the expo floor had the usual vendor announcements, the real story for those of us building AI products was what the keynotes dubbed: "The Great Token Panic."

With Gartner forecasting $2.59 trillion in AI spending in 2026, the era of treating AI costs as an unattributed R&D expense is over. Here are the core takeaways from the event and why they matter for engineering teams.

1. The Arrival of Token Economics

For the last decade, FinOps was about CPU hours, memory, and reserved instances. Now, the atomic unit of technology spend is the token.
Because reasoning and agentic workloads consume 5 to 30 times more tokens per task than simple chat interactions, enterprise consumption is swamping the gradual decline in per-token list prices. AI token costs are variable, hard to forecast, and prone to rapid volatility. Recognizing this, the Linux Foundation and FinOps Foundation used the event to launch the Tokenomics Foundation. It's a massive industry effort uniting hyperscalers and enterprises to establish open standards for AI cost management and billing data.

2. Agentic FinOps and Moving Beyond Dashboards

We are officially moving past static dashboards and natural-language wrappers on billing exports. The conference floor was dominated by the concept of "Agentic FinOps" - autonomous systems that don't just report on costs, but actively investigate and orchestrate remediation.
Instead of analysts manually digging through blast radiuses, the next generation of tooling uses AI to continuously scan Kubernetes clusters, cloud environments, and AI service consumption to automatically route root-cause analysis straight into engineering workflows.

3. FinOps Scopes: Expanding the Definition

The State of FinOps 2026 report made it clear: 90% of teams now manage SaaS costs or plan to within the year. The FinOps umbrella is expanding to cover private clouds, data platforms, software licensing, and, crucially, multi-model AI endpoints.
Optimization efforts fail without accurate allocation. If you can't attribute the cost of an Anthropic or OpenAI API call to a specific product feature or user, you can't optimize it. Teams are shifting to virtual tagging and strict governance frameworks to isolate these costs before they scale.

4. Widespread Adoption of FOCUS

The FinOps Open Cost and Usage Specification (FOCUS) continues to gain traction as the universal billing format. As organizations juggle multiple AI providers, standardizing billing data into a universal schema is the only way to maintain portability. If your infrastructure emits FOCUS-compliant data, you can seamlessly integrate new ecosystem tools without having to rebuild your underlying data pipeline.

How we cut our Dagster Cloud bill by 60% by collapsing our dbt assets

Oskar — Mon, 15 Jun 2026 05:17:03 +0000

If your team is using Dagster Cloud's Solo or Starter tiers, the May 2026 pricing update probably gave you a bit of a shock. By removing the monthly credit allowance and charging for each step-executed asset materialization, workspaces that used to cost $10–$100 a month suddenly spiked into the hundreds or even over a thousand dollars.

At Narev, we love the developer experience of Dagster, but our 24/7 schedule was driving up our bill to the point where self-hosting Airflow was starting to look attractive.

Before jumping ship, we audited our setup and found a massive quick win: we were paying Dagster to coordinate a graph that dbt already understood. Here is how we fixed it and cut our orchestration bill by 60%.

The culprit: `@dbt_assets`

The standard dagster-dbt component is beautiful. You use @dbt_assets, and Dagster maps every single dbt model and seed into an individual node in your Dagster UI.

But under the new pricing model, every asset materialization has a cost (around $0.035 to $0.040 per credit). If you have a couple hundred dbt models running on an hourly or daily partition, you are burning credits just to have Dagster say, "Yep, dbt built this view."

The fix: One asset, One command

We decided to collapse our entire dbt project into a single plain @asset that just shells out to dbt. Same dbt logic, same data, but far fewer orchestration steps.
Here is what our refactored asset looks like:

import json
from dagster import AssetExecutionContext, asset
from dagster_dbt import DbtCliResource
from etl.defs.partitions import daily_partition
from etl.defs.utils import DeploymentType, get_deployment_type

@asset(
    partitions_def=daily_partition,
    group_name="transformers",
    deps=["dw_load"],
)
def dw_transform(context: AssetExecutionContext, dbt_resource: DbtCliResource):
    time_window = context.partition_time_window
    deployment = get_deployment_type()
    dbt_target = "prod" if deployment == DeploymentType.PROD else "dev"

    dbt_vars = {
        "start_date": time_window.start.strftime("%Y-%m-%d"),
        "end_date": time_window.end.strftime("%Y-%m-%d"),
    }

    args = ["build", "--target", dbt_target, "--vars", json.dumps(dbt_vars)]

    # The crucial part:
    result = dbt_resource.cli(args).wait()

    if not result.is_successful():
        raise Exception("dbt build failed")

    return "All models updated"

The gotcha: Drop the context

If you try this, there is one massive trap you need to avoid. Do not pass context=context to dbt_resource.cli().

If you do result = dbt_resource.cli(args, context=context).wait(), the dagster-dbt package will still emit individual materialization events behind the scenes for every single model. You will end up paying for per-model orchestration without getting the per-model UI benefits.

Using .wait() instead of .stream() and dropping the context ensures you only pay for one materialization per partition per run.

The trade-offs

This optimization isn't entirely free. By hiding dbt's complexity from Dagster, you are giving up a few things:

No per-model UI lineage: You won't see individual staging models in the Dagster graph.
Coarser alerting: If a single model fails, the entire dw_transform asset goes red. You'll have to check the dbt logs to see exactly which model broke.

For us, this was a no-brainer. We rely on dbt docs and our warehouse for deep lineage anyway, and we only need Dagster to know: "Extract done → Load done → Transform done."

If you want to see exactly how this changes downstream asset dependencies and how to wire up your jobs with this new pattern, I wrote a full breakdown on our blog (along with a drop-in Cursor prompt to automate the refactor for your workspace).

Read the full guide on the Narev blog

It's time to get familiar with what FinOps for AI is

Oskar — Sun, 31 May 2026 17:05:10 +0000

No Generative AI was used in writing this article. If you enjoyed reading it, please let me know. It helps me dedicate more time to things that resonate with my readers.

It took Uber 4 months to burn the entire AI budget for 2026. The cost if AI, the ROI and the question of AI investment have entered the picture.

Uber’s COO, Andrew MacDonald, said in his recent interview that the costs became “harder to justify” because the link between spending on AI tokens and creating more useful features “was not there”.

It started with all you can eat subscriptions.

Since the early days of tech, we’ve been conditioned to expect all you can eat subscriptions. For a month, you could watch Netflix non-stop, for 24 hours, 7 days a week and you’d still pay the same price as if you watched only one.

That’s a great deal!

In fact, such a good deal, that we see it everywhere. On Netflix, on Amazon Prime, pretty much all the software.

The magic of zero marginal cost (in digital goods)

In traditional businesses, selling one more unit of physical product costs the company an extra unit of resources.

Each flower bouquet of 5 roses sold requires 10 roses. Selling 100 bouquets will require 100 bouquets x 5 roses = 500 roses. This is called marginal cost.

But that’s not the case in the digital world!

Once Netflix pays the massive upfront cost to produce Stranger Things ($30 million an episode), it costs them exactly the same amount of money whether 10 people watch it or 100 million people watch it. As long as they get enough subscriber to cover the initial investment, every new subscriber after that is 100% pure profit. This is a zero marginal cost.

Large Language Models are more like a flower shop

The cost of generating tokens requires significant amount of energy. This makes token generation expensive.

This week news cycle brought us a story about an anonymous company accidentally burning through $500M of tokens.

This very nature of LLMs requires that all-you-can-eat subscriptions have to be subsidized.

Why is it a good thing?

Ultimately, it’s about the unit economics.

We went through a very similar pain with a shift to cloud computing. The solution was to not abandon AWS completely due to spiraling bills.

Instead we built dashboards, tracked usage, and an entire discipline was born: FinOps.

When the costs are real, the value has to be real too.

Where would you start?

I'll leave you with the FinOps for AI framework from Narev.

It was never easier to make software. It was never harder to make good software

Oskar — Sun, 31 May 2026 11:23:21 +0000