At 2:47 a.m. on a Tuesday in early September, I sat in my Lagos apartment and watched a terminal window eat $4,180 in seventy-two hours.
The agent I had built was not doing anything glamorous. It was reading a GitHub issue thread, cross-referencing three block explorers, drafting a patch, running a test suite, failing, and starting over. Fourteen thousand loop iterations. No human in the chair. No coffee. No bathroom breaks. Just a for-loop with a wallet attached to it, quietly converting my USDC balance into someone else's gross margin.
The failure mode was not the one I had prepared for. I had spent weeks hardening the agent against prompt injection, against hallucinated function calls, against the classic mistake of letting a model construct a transaction payload it does not fully understand. What I had not prepared for was arithmetic. The agent was correct. The agent was useful. The agent was also, at the cache-hit rates I was paying, structurally unprofitable at the scale I wanted to run it.
That is the thing nobody tells you about autonomous agents in 2026: they do not fail because they are stupid. They fail because the meter never stops.
Then, on September 10, DeepSeek shipped V4.1 Flash, and the meter moved.
I want to be careful here, because the crypto industry has a bad habit of reading every AI announcement as either a moon signal or an extinction event. This one is neither. It is something more mundane and more consequential: a re-engineering of the cost curve underneath every long-running agent on the planet, announced quietly, priced aggressively, and โ as I will argue over the next several thousand words โ almost certainly misread by most of the on-chain compute market it is about to reprice.
Context
Here is what actually changed, stripped of the marketing.
On September 10, 2026, DeepSeek released V4.1 Flash, and the headline number is this: cache-hit inference during off-peak hours now costs $0.003 per token, down from the $0.022 that the outgoing V4-Pro charged. That is not a promotional discount with a sunset clause. It is a structural price, and the difference between a structural price and a promotional price is the difference between a treadmill and a cliff.
For anyone who has not spent a weekend watching an agent loop burn through a context window, the significance is hard to overstate. Cache hits are the single most important line item in agentic workload economics precisely because agents are repetitive by design. An agent revisits the same system prompt, the same tool definitions, the same repository context, the same conversation history, thousands of times. When you are paying per token, the ratio of cache-hit tokens to cache-miss tokens determines whether your product is a business or a science experiment. DeepSeek just moved that ratio's numerator by an order of magnitude.
The company paired the price cut with a concurrency expansion from 500 to 2,500 requests, which matters more than it sounds. Concurrency is the throttle on everything downstream: how many agents you can run in parallel, how quickly a fleet can fan out, how deep a single workflow can branch before it starts queueing. Going from 500 to 2,500 is not a 5x improvement in a benchmark table. It is permission to design a different class of system.
Official pricing puts the new model at 77 to 80 percent cheaper than its predecessor. DeepSeek's changelog confirms that starting September 14, all requests for the retiring V4-Pro will be automatically routed to V4.1-Flash at the lower price point. There is no migration project. There is no negotiation. One Monday you have a bill, and the following Monday you have a smaller bill with the same API key. That kind of forced migration is the clearest possible signal that the company believes the new architecture is not just cheaper but better.
The engine underneath is the part I actually care about, because the price is a symptom and the architecture is the disease vector. V4.1 Flash ships the industry's first Causal Encoder-Decoder โ CED โ architecture. In a conventional decoder-only transformer, the KV cache for every layer has to be derived from the inputs of that layer, one layer at a time, sequentially, and the memory that accumulates along the way is the thing that forces you to buy more HBM. The CED design does something structurally different: it projects the decoder's global KV cache directly from encoder hidden states, bypassing the need to derive it from every individual decoder layer.
The consequence is an asymmetric activation pattern. The backbone is a 552-billion-parameter Mixture-of-Experts model, but it only activates roughly 8 billion parameters during prefill and 16 billion during decode. Memory overhead collapses. The KV cache lands at 890 bytes per token โ a 75 percent improvement over the previous V4-Flash, and, on DeepSeek's own numbers, one four-hundred-and-thirty-seventh the size of the original DeepSeek V1's cache.
Read that ratio twice. Not 4.37x. Not 43.7x. Four hundred and thirty-seven to one.
And the capability held. In max reasoning effort benchmarks, V4.1-Flash scored 90.6 on Terminal-Bench 2.1, 74.2 on DeepSWE v1.1, and 88.1 on CyberGym, consistently beating the outgoing V4-Pro. On pure non-agentic reasoning it still trails the frontier โ 90.9 on GPQA Diamond against Opus at 93.4 and GPT-5.6 Sol at 94.1 โ but it surpasses its own predecessor on every agentic benchmark while using three times fewer active parameters. The model arrives with a 1M token context window, native multimodal capability, and an MIT license. DeepSeek itself now carries a $71 billion valuation.
I am a crypto analyst, not an AI infrastructure analyst. So why am I writing 6,000 words about a Chinese lab's pricing page?
Because the agent economy is the only growth story in crypto that does not require a new chain, a new token, or a new narrative. It requires something far more boring and far more fragile: a viable unit cost. And as of September 10, that unit cost moved in a way that invalidates a substantial portion of the on-chain compute thesis as it has been sold to investors for the past three years.
Core
The Unit Economics of a Loop
Let me be concrete about the arithmetic, because vague cost talk is how bad capital gets allocated.
Take a realistic on-chain research agent โ the kind of thing a fund, a treasury team, or honestly a solo builder like me actually runs. It monitors governance forums, reads proposal diffs, pulls contract source from a block explorer, checks token holder distribution, cross-references a DEX pool's historical depth, drafts a memo, and requests human sign-off. A single full cycle might consume 180,000 tokens when you include the system prompt, tool schemas, retrieved context, and the working chain of thought.
Now run that cycle in a loop. Not once. Every fifteen minutes, because governance does not wait for you. That is 96 cycles a day, roughly 17 million tokens daily, before you have asked the agent to do anything clever.
At V4-Pro's $0.022 cache-hit rate, that workload is $380 a day of inference โ call it eleven and a half thousand dollars a month, for one agent, doing one job, with no human in the loop. Run a fleet of ten and you are looking at a six-figure annual burn on a product that has not yet earned a single dollar.
At $0.003, the same workload is $52 a day, roughly $1,560 a month. The fleet of ten becomes a $187,000 annual line item that you can actually defend in a budget meeting.
That is the whole game. The difference between $11,500 and $1,560 per agent per month is not a cost optimization. It is the difference between a category that requires venture subsidy and a category that can be bootstrapped.
And here is the part that most crypto teams have not internalized: the cost curve does not move in isolation. It moves in relation to settlement. If your agent reasons for pennies but still pays $0.40 in gas and eats twelve seconds of finality to act on its conclusion, the inference cost was never the bottleneck. It just stopped being the excuse.
The reallocation of attention is what I am watching. For three years, teams blamed model costs for why agents could not run continuously. That excuse expired on September 10. What is left is the settlement layer, the verification layer, and the memory layer โ and those, unlike inference, are problems that crypto is uniquely positioned to solve or uniquely positioned to make worse.
What CED Actually Changes, and Why It Sounds Familiar
I spent the better part of a decade watching blockchains fight the same war that V4.1 Flash just won.
The KV cache is the blockchain state. I mean that almost literally. Both are append-heavy, read-mostly, monotonically growing structures that every participant must hold in fast memory to participate. Both impose a cost that scales not with the number of transactions but with the accumulated history of all transactions. Both create an economic incentive to externalize that cost onto whoever is cheapest to exploit โ in one case, node operators running on consumer hardware; in the other, whoever is paying the inference bill.
Ethereum's answer to state growth was statelessness: prove the state you need, do not store the state you do not. Verkle trees, witnesses, state expiry. The entire research agenda for the better part of a decade was a single question โ how do you shrink the cost of remembering?
CED is DeepSeek's Verkle tree.
By projecting the decoder's global KV cache from encoder hidden states rather than re-deriving it layer by layer, the architecture refuses to pay for redundant memory derivation. It computes the memory structure once, at the encoder, and hands the decoder a pre-built index. The 890 bytes per token is what that refusal costs at rest. The 75 percent reduction versus V4-Flash, and the 437x reduction versus V1, is the accumulated interest on every redundant derivation the industry has been paying since 2023.
I want to be precise about why this is architectural and not merely engineering. You cannot get to 890 bytes per token by tuning kernels or writing better CUDA. You get there by changing what the model is required to remember at each stage of computation. That is a design decision, made once, that pays dividends for the life of the architecture. It is the same species of decision as moving from account-based to UTXO-based settlement, or from calldata to blobs. It is not a 10 percent win. It is a reframing of what the cost function is measuring.
The asymmetric activation pattern reinforces this. A 552-billion-parameter MoE backbone that only lights up 8 billion parameters at prefill and 16 billion at decode is a machine built around the observation that the expensive part of an agentic workload is not thinking. It is remembering while thinking.
Trust the process, but verify the code. And when you verify this code, what you find is that DeepSeek has done something genuinely difficult: it has made the memory problem the primary optimization target, and it has made everything else subordinate to it.
Which is exactly the conversation the crypto compute market has been avoiding.
The Decentralized Inference Market Just Got Repriced
Here is where I am going to say something that will annoy a meaningful number of people who hold tokens in decentralized compute networks.
Those networks are not competing on price anymore. They lost that competition, and they lost it on September 10.
Let me show the work, because I have audited enough of these token models to know that the claims rarely survive contact with a spreadsheet.
A decentralized inference network has a cost structure roughly like this: provider compensation for GPU hours, plus redundancy overhead for verification, plus coordination and settlement costs, plus token emissions to subsidize the gap between what the network pays and what it charges. That last line is the one that matters. Almost every decentralized compute network in existence is buying market share with inflation โ paying providers more than the market would pay them, and charging buyers less than the network pays, with the difference made up by tokenholders who believe in a future where the subsidy is not needed.
That model works when the centralized alternative is expensive. It does not work when a $71 billion lab decides to charge $0.003 per cache-hit token during off-peak hours and increases concurrency fivefold while beating its own previous flagship on agentic benchmarks.
I am not saying decentralized inference is dead. I am saying the specific pitch โ cheaper than the cloud, and that is the value proposition โ is now a losing pitch, and the networks that have raised at valuations predicated on that pitch are going to have a very uncomfortable 2027.
What survives is the part of the pitch that was never about price. A decentralized inference network's durable advantage is not cost. It is verifiability, censorship resistance, and jurisdictional independence. If you need to prove to a regulator, a counterparty, or a DAO treasury that a specific model with a specific weight hash produced a specific output on a specific input at a specific time, a centralized API โ even a cheap one โ structurally cannot give you that. Not because it is untrustworthy, but because it was never designed to be audited. Its entire value proposition is that you do not have to look inside.
The networks that understand this are pivoting, and you can see it in the architecture they are shipping. They are moving away from generic GPU rental and toward attested execution: TEEs that sign their own outputs, deterministic kernels that can be replayed bit-for-bit, cryptographic commitments to model weights that a verifier can check without re-running the whole forward pass.
Meanwhile, the networks still selling raw GPU hours at a discount are competing against a cost curve that is falling faster than their emissions schedule. That is a war of attrition against an opponent with better hardware, better software, and a lower burn rate. I have watched enough DeFi protocols attempt to subsidize their way past a superior competitor to know how this ends. The subsidy runs out first.
There is a deeper irony here that I cannot stop thinking about. DeepSeek's release is Chinese open-weight compression at its absolute peak โ an MIT-licensed model that anyone can download, run, and modify. In a very real sense, DeepSeek just handed the decentralized compute movement its best possible gift: a frontier-adjacent model whose weights are free, whose license is permissive, and whose architecture is public. Every decentralized GPU network on earth can now serve this model without paying a licensing fee or negotiating with an API gatekeeper.
And yet the dominant reaction in crypto telegram groups was to treat the price cut as a threat.
That reaction tells you something important about what these networks actually are. A real decentralized compute market would see an open-weight, efficiently architected, MIT-licensed model as raw material. A token subsidized around a centralized API resale arrangement sees it as margin compression. The difference between those two reactions is the difference between infrastructure and a middleman.
When Compute Is Cheap, Proof Is the Product
I run something called the Verifiable Truth Initiative โ a consortium working with ten tech firms and around 500 content creators to authenticate AI-generated content using blockchain infrastructure. I mention it not to sell you anything but to explain why the September 10 announcement landed on my desk with a particular weight.
The premise of the Initiative is straightforward: in a world where generating content, code, and decisions is approaching zero marginal cost, the scarce good is not generation. It is provenance. Nobody will pay $0.003 to know that a model output a sentence. Millions of people will pay a great deal more than that to know that a specific model, with a specific weight hash, running on specific hardware, produced that sentence in response to a specific input at a specific time, and that no one edited it afterward.
V4.1 Flash makes generation cheaper by roughly 80 percent. That is not a threat to provenance businesses. It is a 5x increase in the volume of things requiring provenance.
Here is the mechanism, and this is the insight that I think most of the market is missing. When inference becomes cheap enough to run continuously and autonomously, the number of AI-generated artifacts that affect someone's money, reputation, or legal standing explodes โ and every one of those artifacts needs to be attributable to survive scrutiny.
An agent that reads a governance proposal and recommends a vote is a system whose output will be questioned. An agent that rebalances a treasury will be questioned by an auditor. An agent that generates a news summary will be questioned by the person it defames. At $0.022 per cache-hit token, you run these agents sparingly, on high-value tasks, with a human watching. At $0.003, you run them constantly, across everything, and the human watching becomes a spot check rather than a supervisor.
Spot checks are exactly the regime in which attribution infrastructure becomes load-bearing.
The technical options for proving inference are three, and they have very different cost profiles, which is why the DeepSeek price cut interacts with each of them differently.
The first is zero-knowledge machine learning โ ZKML โ where you produce a cryptographic proof that a computation was performed correctly. The elegance is unmatched. The problem is cost. Proving a forward pass through a large model is orders of magnitude more expensive than performing it, and the gap widens as models grow. At current proof system efficiency, ZKML is viable for small models on high-value computations and structurally impossible for 552-billion-parameter backbones. If someone tells you they are ZK-proving a frontier agent's full inference trace in production, ask them for the verifier's gas cost. Then ask them again.
The second is optimistic machine learning โ opML โ where an output is accepted unless someone challenges it within a window, at which point the computation is re-run and adjudicated. This is fraud-proofs, transplanted from rollups into machine learning. The cost profile is attractive because you only pay for disputes. The weakness is the challenge window, which is a latency tax on finality โ and in agentic systems, latency is the thing you are least able to afford.
The third is trusted execution environments โ TEEs โ where hardware attests to what code ran on what input and signs the output. This is the cheapest of the three by a wide margin and the one most production systems are quietly converging on. It is also the one with the weakest trust model, because you are trusting a hardware vendor's attestation chain rather than mathematics.
I have spent enough time in this space to have opinions about which one wins, and my honest answer is that it depends on what you are securing. But here is the observation that matters for the September 10 reprice: when generation costs fall by 80 percent, the relative cost of verification rises by 400 percent in proportional terms โ not because verification got more expensive, but because the thing being verified got cheaper. The ratio is the whole story.
That ratio is where on-chain infrastructure earns its keep. A Merkle root of attested outputs, anchored periodically, costs a rounding error in gas and gives you tamper-evident provenance for an unbounded number of inferences. You do not need to put inference on-chain. You need to put commitments to inference on-chain, and let verification happen off-chain, cheaply, by whoever cares.
Trust the process, but verify the code. In this architecture, the chain's job is not to do the work. Its job is to make the work checkable.
The Rails Problem: Agents Need to Pay
Cost is only half of a unit economics problem. The other half is settlement, and this is where the crypto industry's three-year head start has produced less than it should have.
An agent that runs continuously needs to pay for things continuously. Inference, storage, data feeds, compute, and โ increasingly โ other agents. Micropayments in the range of fractions of a cent, thousands of times a day, with finality fast enough that a downstream agent can act on the result without waiting.
I want to be direct about the rails question, because there has been a decade of fantasy here and the bill is coming due.
Bitcoin's Lightning Network is not going to be the payment rail for the agent economy. I have been watching Lightning since 2019, and the failure modes have not changed: routing failures on non-trivial payments, inbound liquidity management that requires active attention, channel rebalancing that is its own job, and an operational complexity tax that makes sense for a merchant with predictable flows and a nightmare for an agent making unbounded, unpredictable, tiny payments. Seven years in, the network is still a niche. Agents will not be the thing that rescues it.
What actually works, and works today, is stablecoins on high-throughput chains. A USDC transfer on a modern L2 costs fractions of a cent, settles in seconds, requires no channel management, and has an ecosystem of payment facilitators who will abstract the signing layer entirely.
The 2026 agent-payment stack is already visible, and it looks like a handful of emerging standards โ HTTP-native payment negotiation where an agent receives a 402 response and settles automatically, registries that let agents discover and trust one another's identities, and session-based payment channels that let a fleet of agents settle net rather than gross. None of it is glamorous. All of it is what actually moves money between machines.
And every one of those rails terminates on an L2.
Which brings me to a structural risk that I think is being aggressively underpriced right now, in the middle of a bull market, by people who have never read a blob fee market.
Rollup data costs are going to get more expensive, not less, at exactly the moment agents start using them most.
The bandwidth that rollups use to post data to Ethereum is a fee market with a target utilization rate. When demand sits at or below target, fees are low and stable. When demand sustains above target, the base fee adjusts upward โ and the adjustment is exponential, not linear. That is by design. It is what keeps the system from being DoS'd.
For the past two years, blobspace has been underutilized. Rollups got cheap. Everyone wrote blog posts about how L2 fees were approaching zero. That era is ending, and it is ending for a reason nobody in the rollup discourse has fully priced: AI data availability.
The same forces driving inference costs down โ continuous agents, continuous generation, continuous verification โ are producing continuous data. Attested outputs, provenance logs, training corpora, memory snapshots, inference receipts. All of it wants to be anchored somewhere, and the cheapest somewhere with the strongest guarantees is Ethereum blobs.
When agent-generated data availability demand collides with rollup blob demand on a fee market with a target utilization rate, the sustained state is above-target, and above-target means exponential adjustment. I have modeled this and the numbers are not gentle. A sustained 2x over-target utilization does not produce a 2x blob fee. It produces a fee that roughly doubles every few blocks until demand clears.
I am not predicting a specific date. I am predicting a mechanism, and the mechanism is not in question. Anyone pricing agent infrastructure on today's L2 fees is pricing on a subsidy that is going to expire.
There is one more piece of this, and it is the piece that quietly breaks agents in ways that look like model failures.
Oracle latency is the thing that turns a correct agent into an incorrect one, and almost nobody instruments for it.
Consider an agent whose job is to act on a market condition. It subscribes to a price feed, evaluates a condition, and submits a transaction. The feed updates on a heartbeat and a deviation threshold. The heartbeat is measured in minutes on some feeds and seconds on others. The deviation threshold means the feed does not update at all until price moves past a band โ which means during a slow drift, the feed is not stale in the way a timeout would flag, it is stale in a way that looks fine.
I have audited enough systems that consume price data to know how this fails. The agent's decision is correct given its inputs. The inputs are not current. The gap between the two is measured in a window that no one logs and no one alerts on, because the feed technically updated. You get a liquidator that liquidates at a price that no longer exists, a rebalancer that rebalances into a move that already happened, a treasury that hedges against a level that was breached ninety seconds ago.
In a human-operated system, this is a known risk with known mitigations โ circuit breakers, manual confirmation, position limits. In an autonomous agent running continuously at near-zero inference cost, the mitigation has to be architectural, because there is no human in the loop and the loop never stops.
The fix is not a better oracle, although better oracles help. The fix is that agent architectures need to treat feed freshness as a first-class input, timestamp every decision against the observation it used, and refuse to act on data whose provenance window it cannot verify. That is an on-chain problem โ you need verifiable timestamps and verifiable data provenance โ and it is a problem that crypto is well-suited to solve and has largely ignored in favor of building more venues to trade on.
The September 10 price cut makes these problems urgent rather than theoretical, because it makes continuous operation the default instead of the exception.
Memory Is the New State
There is one more layer, and I saved it for last because it is the one where I think the real money is, and the one where the crypto industry's existing primitives are most applicable and least applied.
V4.1 Flash ships a 1M token context window. That is a lot of memory in a single call. But context windows are not persistent memory. An agent with a million-token window still forgets everything when the process ends, and a long-running agent's value is precisely in what it accumulates.
So where does an autonomous agent's memory live?
Some of it lives in the model's context โ expensive, ephemeral, bounded. Some lives in a vector store โ cheap, retrievable, unverifiable. Some lives in a database โ durable, queryable, and completely opaque to anyone who did not build it.
The 890-bytes-per-token KV cache is an interesting number here, because it tells you the exact cost of the one form of memory that is mathematically faithful to the model's own internal state. Everything else โ embeddings, summaries, retrieval โ is a lossy compression of that state, and lossy compression is where agents develop personality disorders.
I have watched this play out in my own projects. An agent that maintains its own narrative of what it has done will drift. It will remember a decision it made but not the caveat that accompanied it. It will recall that a proposal passed but not that the vote was contested. Over thousands of iterations, the drift compounds, and the agent you have at the end is not the agent you deployed.
The on-chain version of this problem has been solved before, partially. Content-addressed storage gives you immutability and retrievability. Merkle commitments give you verifiability. Access control gives you privacy. What has not been solved is the economics of a memory store that grows continuously, is queried constantly, and needs to be provably unaltered.
That is, structurally, exactly the problem that a blockchain solves for financial state. And it is a problem that no current chain solves economically for agent memory, because the write volume is enormous, the read pattern is aggressive, and the value per byte is low.
Which points at something I have not seen anyone build yet, and which I think is the most interesting open surface in this space: a memory layer for autonomous agents with content-addressed writes, verifiable reads, and a fee market that makes continuous growth sustainable.
Do that, and you have the missing piece of the agent stack. Do not, and every agent in production remains a session-scoped novelty with amnesia.
Contrarian
Now let me argue against myself, because the bullish read of the September 10 announcement is that cheap inference is unambiguously good for crypto. I do not think that is true, and I think the counter-argument is the more interesting one.
Cheap inference is net negative for every token whose value proposition is compute scarcity.
If you hold a token that is supposed to appreciate because GPUs are scarce, or because inference is expensive, or because access to frontier models is gated, then a well-capitalized competitor just made your underlying scarce resource 80 percent less scarce while increasing their capacity fivefold. Token models built on the assumption that the network can charge a premium for compute have been repriced, and the repricing is not going to show up in a chart until the emissions schedule forces it.
The second-order effect is worse. Jevons paradox says that when a resource gets cheaper, total consumption goes up โ not down. But it does not say the suppliers get richer. Cheap inference means agents run more loops, which means more settlement, more data availability, more verification, more memory writes. Volume explodes. The question is who captures the value, and the honest answer is that in a commoditized market, value accrues to whoever owns the bottleneck that did not commoditize.
Inference is no longer a bottleneck. It is a commodity with a published price that fell by 80 percent in a single day. What did not commoditize? Verification. Settlement finality. Data availability. Persistent memory. Identity and trust between machines. Provenance.
Every crypto team building an inference layer right now is building on the wrong side of that line, and every crypto team building verification or settlement infrastructure is building on the right side of it without necessarily knowing why the wind just shifted in their favor.
The other blind spot is more subtle and, I think, more dangerous. Everyone is modeling the agent economy on inference cost, and almost nobody is modeling it on settlement latency.
An agent that thinks for free and settles in twelve seconds still cannot compete with an agent that thinks for pennies and settles in two hundred milliseconds. The bottleneck is migrating from the model to the chain, and the chain's performance has not improved on anything like the schedule that inference costs have. If agents become a meaningful share of on-chain activity โ and at $0.003 per cache-hit token, they will โ then block space, not GPU time, becomes the constrained resource, and the L2 blob fee market I described earlier stops being a theoretical concern and starts being the single most important number in the agent economy.
I would rather be early to that realization than late.
Takeaway
On September 10, DeepSeek made the cost of thinking small enough to ignore. On September 14, every request will route to the new model automatically, and most teams will notice their bill dropped and move on with their roadmap unchanged.
That is the mistake. The bill is the least interesting thing that changed.
What changed is that the excuse for not running agents continuously has been removed, and in its place, four problems have become the actual constraint: proving what a model did, settling what it owes fast enough to matter, keeping its memory verifiable without going bankrupt, and feeding it data whose provenance you can trust. Each of those is a crypto problem. Each of those is unsolved. And each of those is now the reason a project will fail rather than the reason a project will cost too much.
Trust the process, but verify the code. The code just got cheaper. The verification is where the next decade of value is going to be built โ and I would rather be building it now, at 2:47 a.m., watching a terminal window that no longer eats four thousand dollars in a weekend, than explaining in 2029 why I spent the interim optimizing the wrong line item.
The question worth sitting with is not whether agents will run continuously. They will. The question is whether the infrastructure they run on will be something you own, or something you rent from a company that just showed you, on a Monday morning, exactly how fast it can change the price of your entire business.