The biggest AI story this week did not start with a launch. It started with a takedown. A US export control order pulled two frontier models offline, and the shock reached coding tools, chip strategy, and the open protocols that hold agent systems together. Here is what happened across the three areas that matter most for builders.
AI Coding Tools: A Mythos-Class Model Arrives, Then Vanishes
The week split into a before and an after. Before June 12, the coding-tool conversation centered on a new top-tier model and another round of pricing changes. After June 12, it centered on a question almost nobody had planned for: what do you do when a government turns off the model your workflow depends on?
Claude Fable 5 Launched, Then Got Pulled in Three Days
Anthropic released Claude Fable 5 on June 9, 2026. The model was the company's first public release in its new Mythos class, a tier that sits above the Opus line in raw capability. Fable 5 shipped inside Claude Code and arrived in GitHub Copilot the same day for Pro+, Max, Business, and Enterprise subscribers. Cursor users could route to it through the Anthropic API. For three days, it looked like the strongest coding model on the market.
Then it disappeared. On June 12 at 5:21 PM Eastern, Anthropic received a US export control directive ordering it to suspend all access to Fable 5 and Mythos 5 by any foreign national, inside or outside the United States. That scope included Anthropic's own foreign-national staff. The company could not filter users by nationality in real time across dozens of cloud platforms. So it shut both models down for everyone.
The reach of the order was wide. Reporting from Quartz and others noted that Commerce Secretary Howard Lutnick sent the letter directly to CEO Dario Amodei. The shutdown hit AWS Bedrock, Google Cloud, Microsoft Foundry, Snowflake, Box, and the direct Claude API at the same time. Access to every other Claude model, including Opus 4.8, stayed online. Developers who had pinned their agent stacks to Fable 5 woke up to a model that no longer existed.
Anthropic pushed back in public. The company said the order stemmed from a narrow jailbreak, a code-reading technique that triggered a capability the government flagged on national security grounds. Anthropic argued that recalling a model used by hundreds of millions of people over one narrow exploit sets a standard that would freeze frontier launches across the whole industry. It called the action a misunderstanding and said it is working to restore access.
For builders, the lesson lands hard. This looks like the first government-forced takedown of a publicly deployed frontier model. A model is not a stable dependency. It is a service that can vanish on a Friday evening with no warning and no migration window. Teams that hard-coded one model name into agent prompts, eval suites, and CI pipelines learned the cost of single-model coupling in one night.
Why the Suspension Reshapes How You Build
The fix is not new, but the week made it urgent. Route through an abstraction layer, not a hard model string. Keep a tested fallback model wired into every agent path. Run your eval suite against at least two models so a swap does not break behavior you cannot see.
The security angle matters too. Snyk's write-up pointed out that the reported trigger was a code-analysis capability that defenders use every day. The same skill that helps a security team read a hostile binary can read a sensitive one. That tension will shape how the next class of models ships, and how much capability gets gated behind classifiers before release.
There is a business subplot. Fortune reported that Anthropic confidentially filed for a public listing earlier in June, with a recent round valuing the company near $965 billion. A government that singles out your flagship models adds a new risk line to any IPO story. Investors now have to price the chance that a regulator pulls your best product without explanation.
GitHub Copilot Moves to Usage-Based Billing
The pricing story did not pause for the drama. GitHub moved Copilot from request-based billing to usage-based billing on June 1, 2026, and the new structure is now live. The shift changes the math for heavy agent users, who burn tokens fast in long autonomous runs.
The current individual plans, verified from GitHub's pricing page on June 15, set a clear ladder. Free gives 2,000 completions per month plus access to Haiku 4.5 and GPT-5 mini. Pro runs $10 a month with unlimited completions, cloud agent access, and $15 in included AI credits. Pro+ runs $39 a month with premium model access and $70 in credits. Max runs $100 a month with priority model access and $200 in included credits.
The credit model rewards teams that watch their spend. A developer who runs agents all day lands far above the base tier. GitHub's own docs admit that daily agent users often pay $60 to $100 a month in practice, not the $10 sticker. The era of a flat coding-assistant subscription is closing. Token accounting is now part of the job.
Cursor Crosses $2B ARR as the Market Splits
Cursor keeps climbing. The company behind it, Anysphere, reached $2 billion in annual recurring revenue, with revenue that doubled every two months across a long stretch of 2025 and early 2026. Cursor's path ran from $100 million ARR in January 2025 to $1 billion by mid-year and past $2 billion since.
The competitive picture sharpened. A JetBrains survey of developers with more than ten years of experience found that 46% picked Claude Code as their daily tool and 9% picked Copilot. Copilot's overall share slid from 67% to 51% over the same window. Microsoft has responded with agent mode, bring-your-own-key model support, and access to Anthropic's protocols inside VS Code Insiders. The read from the field is that Copilot is extending a legacy product while Cursor and Claude Code were built around agents from the start.
The tools are also converging into one stack. The New Stack framed it well: most real teams now run more than one tool at once. Autocomplete tools work at line-level latency, sub-second and scoped to the open file. Agentic tools take a task and run for minutes across many files. These are different categories, not rivals. A team that codes mostly incremental edits wants strong autocomplete. A team shipping features across five services wants agents. Most need both, which is why multi-tool stacks became the norm in 2026 rather than the exception.
The Wider Pricing Reset
Copilot was not alone in changing its bill. The whole market reset its pricing in the first half of 2026. OpenAI moved Codex to token-based credits on April 2, 2026, for most Plus, Pro, Business, and Enterprise customers. The old all-you-can-eat framing gave way to metered usage across nearly every vendor at once.
Cursor's ladder grew a rung. The company added Pro+ at $60 a month between Pro at $20 and Ultra at $200, per its current pricing. Cursor's own docs warn that daily agent users land closer to $60 to $100 a month than the $20 sticker. The pattern repeats across the field. The headline price buys a starter bucket of tokens, and real agent work spends past it.
The spreadsheet you saved six months ago is wrong. New model tiers, renamed products, and metered billing moved the numbers faster in early 2026 than in any comparable stretch. A team that picks a tool on last quarter's pricing page will misjudge its real monthly cost. The work now includes tracking token spend the way you track cloud spend.
Agents Move Beyond Code
The agent model is spreading past the IDE. Anthropic introduced Cowork earlier in 2026, described as Claude Code for general computing. The product runs the same agent loop across spreadsheets, file management, report drafting, and workflow tasks for people who do not write code. The coding agent became a template for knowledge work.
The company also took the message on the road. The Code with Claude conference ran in San Francisco on May 6, then London on May 19, then Tokyo on June 10. The tour confirmed a shift in the business model. The product is no longer a license for an assistant that completes lines. It is the sale of an agent that does whole tasks, billed by what it consumes.
The skills ecosystem amplifies the pull. Anthropic's guide for scaling Claude Code in enterprise codebases became one of the most-read documents in the field, and a market of reusable skills built a network effect around the tool. When a workflow library grows around a product, switching costs grow with it. That is part of why Claude Code's share climbed so fast among senior developers.
The Quality and Security Reality
The productivity gains are real, and so are the catches. A Veracode study found 45% of AI-generated code fails security tests, with 62% of samples carrying design flaws. The risk is manageable with code review and automated scanning, but it does not vanish because the code came from a strong model. Review discipline matters more as agents write more.
The payback picture is sober. About 62% of teams report at least a 25% productivity gain, mostly on routine coding. True costs run two to three times the subscription fee once you count review, rework, and tooling. Only a small share of firms have measured a clear payback, and most successful teams reach return on investment over two to four years, not two to four weeks. The tools help. They are not magic, and the bill is real.
The Contract Fine Print Just Got Tested
The Fable 5 shutdown exposed a gap in enterprise contracts. Many service agreements lean on force majeure clauses that never imagined an instant government-mandated cutoff. One analysis noted that incident teams found the hard limits of legacy compliance language overnight. A clause written for natural disasters does not cover a regulator pulling a model.
The lesson for procurement is concrete. Read the model-availability terms in your vendor agreement. Ask what happens to your workloads if a specific model goes dark with no notice. Build the answer into your own service levels so a vanished model becomes a known fallback path, not an emergency. The teams that wrote substitution into their contracts slept fine on June 12. The teams that assumed a model would always be there did not.
The Model Is Not the Moat
The week reframed where durable advantage lives. A model can launch on Tuesday and vanish on Friday. So the model itself is a poor place to build a moat. The lasting edge sits in the layers you own: your eval suite, your workflow library, your data access, and the standards that let you swap parts without a rewrite.
This is the quiet argument running under the whole coding-tool race. Claude Code's pull among senior developers came less from any single model and more from the skills ecosystem and enterprise guidance around it. Cursor's growth came from a product built around agents, not from owning a model. When models commoditize and swap in and out, the workflow and the data underneath decide who wins.
Evals Become the Asset You Keep
The June 12 shutdown made one point sharp: your eval suite is the asset that survives a model swap. When Fable 5 vanished, teams with strong evals could test Opus 4.8 against the same tasks and measure the gap in an hour. Teams without evals had to guess whether their prompts still worked.
Evals are how you turn a model change from a crisis into a routine check. A good suite captures the tasks you care about, the edge cases that bite, and the quality bar you ship against. Point it at a new model and you get a number, not a hunch. That number is what lets you swap models on purpose rather than in a panic.
The investment compounds. Every eval you write keeps paying off across every future model. The model you run today will not be the model you run next year, but the tasks you need it to do stay mostly the same. Build the eval suite once, and you own a stable measuring stick for a market that will not stop moving.
AI Processing: Nvidia Goes After the PC, Custom Silicon Goes After Nvidia
Hardware news this week pulled in two directions at once. Nvidia pushed down into the laptop and desktop market it never owned. Its biggest cloud customers pushed up into the inference market Nvidia has owned for years. The result is a chip landscape where the lines between training, inference, and on-device work keep blurring.
Nvidia's RTX Spark Aims to Reinvent the PC
At Computex in Taipei on June 1, 2026, Nvidia CEO Jensen Huang introduced the RTX Spark Superchip, a system-on-chip aimed at Windows machines. Huang said Nvidia and Microsoft plan to "reinvent the PC." The move pushed Nvidia into a market it had mostly skipped while it built its data center empire.
Wall Street read the threat fast. Shares of AMD, Intel, and Qualcomm slid on the news. Those three have built their plans around the PC and the edge, and Nvidia just walked onto their turf with a chip designed to run local models on consumer hardware. The pitch is simple. If you own the data center, the workstation, and now the laptop, you own every layer where AI runs.
The on-device angle is the part that matters for app builders. Laptop-class chips now carry real AI horsepower. NPUs in current SoCs from Intel, AMD, and Apple deliver 40 to 50 TOPS of local inference, per a 2026 hardware survey. For small-batch work, those dedicated NPUs run 10 to 15 times more power-efficiently than GPU execution. That changes which models you run in the cloud and which you run on the machine in front of you.
The PC Becomes an AI Device
Nvidia's PC push lands on hardware that finally has the power to matter. A laptop that runs a useful model locally changes the privacy math. Data that never leaves the device cannot leak from a cloud breach. For health, finance, and legal work, local inference turns a compliance headache into a design feature.
The split-tier pattern follows from there. Fast, private, small-model work runs on the device. Heavy reasoning and large-context jobs go to the cloud. The application decides which tier handles each request based on data sensitivity, latency budget, and model size. That routing logic becomes part of the product, not an infrastructure detail buried in ops.
This reshapes data architecture in a concrete way. A local tier needs its own slice of data and its own access rules, kept in sync with the cloud tier. The boundary between them is where governance lives. Plan that boundary early, because retrofitting privacy onto a system that assumed everything ran in the cloud is the hard way to learn this lesson.
The Hyperscalers Surround Nvidia With Their Own Chips
Nvidia's best customers are now its sharpest rivals. Amazon, Google, and Microsoft each ship second- and third-generation AI processors of their own design, according to a recent chip-wars analysis. Analysts expect custom silicon to capture 15 to 20% of the AI inference market and 10 to 15% of training by 2026, up from under 5% a year earlier.
Amazon leads on volume. More than 60% of AWS machine learning instances now run on some form of Amazon silicon, from Inferentia to Trainium, with Trainium3 already in development for trillion-parameter models. Google keeps pushing TPUs into inference, not just training. Its TPU 8i carries three times more on-chip SRAM for longer KV cache, a Collectives Acceleration Engine for faster token sampling, and a network topology that cuts all-to-all latency in half for mixture-of-experts and reasoning workloads.
The pattern is clear. Each hyperscaler wants its own chips to be the default for most AI services while keeping Nvidia GPUs around for customers who ask. That gives them pricing power, supply control, and a hedge against Nvidia's margins. For teams picking where to run inference, the menu got longer and the price points got more spread out.
Inference Chips Get Specialized and Faster
The inference market is splitting off from training as its own hardware race. Nvidia's own Groq 3 LPX inference accelerator folds in the high memory bandwidth design from Groq, which Nvidia bought for $20 billion in late 2025. The product pairs Groq's low-latency approach with Nvidia's processing, aimed straight at the latency-sensitive serving market.
Memory keeps moving to the center of the design. At CES in January, both Nvidia's Rubin platform and AMD's Helios platform made memory the headline feature, since reasoning models need to hold long context and large KV caches in fast memory. The bottleneck for modern inference is rarely raw compute. It is how much state you can keep close to the cores and how fast you can move it.
Open challengers keep arriving too. The week brought reports of new model releases from outside the big US labs, including a fresh GLM model from Z.ai, which keeps pressure on cost-per-token across the serving market. When a capable open model lands, the price of every closed model that serves the same task gets a fresh test.
Export Controls Reshape the Supply Chain
Chips are now a geopolitical instrument, and the same week proved it twice. The Fable 5 takedown was one example. The chip supply is another. On January 14, 2026, the US Bureau of Industry and Security shifted its license policy for advanced AI chips bound for China from presumption of denial to case-by-case review for Nvidia H200 and AMD MI325X-class parts.
The change cuts both ways. Case-by-case review opens a door that was nearly shut, but it adds uncertainty to every cross-border deployment plan. A data center build that depends on a specific accelerator now carries license risk on top of supply risk. Vendors design product lines around these rules, which is why China-market parts and global parts keep diverging.
Chinese makers fill the gap with their own inference parts. Domestic accelerators aimed at the H20 price-performance band keep shipping, which keeps a second supply track alive inside China. For teams with global footprints, the takeaway matches the coding lesson: avoid hard dependence on one part you cannot guarantee you can buy next year.
Open Hardware Pushes Against CUDA
Nvidia's software moat draws steady challengers. Tenstorrent ships RISC-V accelerators, and Intel keeps an open software stack around Gaudi, both pitched as alternatives to CUDA lock-in. Intel's Gaudi 3 targets the cost-sensitive band, claiming strong price-performance against older Nvidia parts on large-model inference.
The open-stack pitch is about freedom to move. CUDA is fast and mature, but it ties your kernels to one vendor. ROCm and open RISC-V stacks trade some maturity for portability. The choice mirrors the protocol debate one layer up. You pay a little in convenience now to keep the option to switch later.
The edge keeps its own race. Nvidia's Jetson holds the high-performance edge slot at 275 TOPS, but its power budget rules out battery work. For always-on, low-power inference, dedicated NPUs win on TOPS per watt by a wide margin. The right edge chip depends on whether you tune for peak throughput or for battery life, and those two goals pull toward different silicon.
What This Means for Data and Inference Costs
For data teams, the through-line is cost and placement. The model you pick is now tied to the chip it runs on and the memory that chip carries. A reasoning model with a long context window costs more to serve on memory-starved hardware. The same model runs cheaper on a chip built for long KV cache.
Memory Is the New Bottleneck
The hardest part of serving a modern model is rarely the math. It is the memory. Reasoning models hold long chains of thought and large key-value caches, and all of that state has to sit in fast memory next to the cores. When the cache spills, latency climbs and cost climbs with it.
This is why the latest chips lead with memory. The TPU 8i added three times more on-chip SRAM precisely to hold longer KV cache. AMD's MI300X wins on jobs where raw memory capacity per chip cuts sharding complexity and lifts real throughput. The spec sheet line that matters most for inference is no longer peak FLOPS. It is memory capacity and bandwidth.
The practical effect reaches your bill. A model that fits in memory on one accelerator and spills on another shows a wide cost gap for the same workload. Sizing your hardware to your context window length is now a core part of serving design, not an afterthought you tune later.
On-device inference reshapes the data path. When a 40-TOPS laptop can run a useful model locally, some queries never touch the cloud. That cuts latency and keeps sensitive data on the machine. It also splits your architecture into a local tier and a cloud tier, each with its own model and its own data access rules. Planning for both is now a first-class design choice, not an edge case.
Standards and Protocols: The Agent Stack Gets Its Plumbing
Models grab the headlines, but protocols decide whether agents can actually work together. This week the open-standards layer moved forward on two fronts: a developer summit that drew the community together, and a spec cycle that pushes agents from isolated tools toward composable systems.
MCP Dev Summit Lands in Mumbai
The Model Context Protocol community met in Mumbai on June 14 and 15, 2026, for an MCP Dev Summit co-located with Open Source Summit India and KubeCon plus CloudNativeCon India. The summit is one stop in a global series that runs through 2026, with stops planned for Seoul, Shanghai, Tokyo, Toronto, and Nairobi, plus flagship AGNTCon and MCPCon events in Amsterdam in September and San Jose in October.
The series tells you something about where MCP sits now. A protocol that started as one company's idea in late 2024 draws conference halls full of developers in 2026. MCP handles the agent-to-tool connection. It is the layer that lets a model read a file, run a function, or query a database through one standard interface instead of a custom connector per source.
The scale is real. Community registries index more than 18,000 MCP servers, and the official MCP Registry is moving toward general availability with signing and trust scoring on the roadmap. SDK downloads run in the tens of millions per month across Python and TypeScript. When a standard hits that kind of adoption, it stops being optional for anyone building production agents.
The Next MCP Spec Pushes Toward Composable Agents
The protocol's roadmap points at recursion. The next spec cycle is set to address server-as-agent capabilities, where MCP servers connect to other MCP servers and compose into larger systems. That turns a flat tool list into a tree of agents that call each other through the same standard.
The release candidate work also points at a leaner core. The draft direction includes a stateless protocol core, an Extensions framework, a Tasks model for longer-running work, MCP Apps for richer interfaces, hardened authorization, and a formal deprecation policy. The stateless move matters most at scale. Early MCP leaned on long-lived sessions, which made load balancing and cloud scaling hard. A stateless core removes the sticky-session bottleneck and lets agents connect to a pool of servers without state headaches.
Security is the part that keeps getting fixed. Earlier research found many deployed MCP servers shipped with weak authentication. The OAuth 2.1 update helped, but adoption stayed uneven. Prompt injection against tool descriptions is still an open problem. Each spec cycle tightens these gaps, and each tightening is the difference between a demo and a system you can trust with real data.
Tasks and MCP Apps Change What Agents Can Do
Two additions in the spec direction stand out for builders. The Tasks model handles work that runs longer than a single request. Early MCP fit quick tool calls that returned fast. Real data jobs do not. A large scan, a model training step, or a multi-stage pipeline runs for minutes or hours, and Tasks gives agents a clean way to start that work, track it, and collect the result without holding a connection open the whole time.
MCP Apps push the other direction, toward richer interfaces. A plain tool returns text. An MCP App can return an interactive surface the agent and the user work with together. For data work, that means an agent can hand back a chart, a table the user filters, or a form the user fills, all through the same protocol that carries the tool calls. The agent stops being a text pipe and starts driving real interfaces.
Together these features close the gap between a chat demo and a working system. Long-running Tasks match how data pipelines actually run. Richer App surfaces match how people actually review results. The protocol is growing into the shape that production data work needs, one spec cycle at a time.
A2A and the Foundation That Governs the Layer
The agent-to-agent side of the stack runs in parallel. The Agent2Agent protocol, started by Google with more than 50 partners, handles peer coordination through Agent Cards that let agents discover and call each other across vendors and frameworks. MCP connects agents to tools. A2A connects agents to agents. Most production designs now use both: MCP for tool access and A2A for coordination.
Governance moved to neutral ground. The Agentic AI Foundation, under the Linux Foundation, now stewards MCP, A2A, AGENTS.md, and the goose agent framework together. Open governance gives enterprises a reason to commit. A protocol run by one vendor carries lock-in risk. A protocol run by a neutral foundation gives teams portability, the freedom to move workloads between environments without a rewrite.
For data engineers, this is the part that changes daily work. When your warehouse, catalog, and query engine speak MCP, an agent can reach live data through one interface and act on what it finds. The standards layer is what turns a chat model into a system that queries production tables, checks the result, and takes the next step. That is the bridge between AI and the data it needs to be useful.
How Agent Cards Actually Work
A2A's discovery model rests on a small idea with big reach. Each agent publishes an Agent Card, a structured description of what it does, how to reach it, and what it expects. Another agent reads the card and decides whether to hand off a task. The card is the handshake that lets agents built by different vendors find and trust each other.
This is what makes cross-vendor coordination practical. Without a shared discovery format, every agent pairing needs a custom integration, the same N-times-M problem MCP solved for tools. Agent Cards turn that into a lookup. An agent that needs a translation step finds a translation agent through its card and calls it, with no prior wiring between the two teams.
The security work tracks the tool side closely. Delegation chains, where one agent acts on behalf of another, need clear authorization at each hop. The guidance for teams building now is to design those chains from day one rather than bolt them on later. An agent network without delegation controls is a network where one compromised agent reaches everything.
What Server-as-Agent Unlocks for Data Pipelines
The server-as-agent direction matters most for data work. Today an MCP server exposes tools to one agent. With recursive composition, a server can act as an agent itself and call other servers. A data pipeline becomes a tree: a top agent asks a catalog server for tables, the catalog server asks a storage server for files, and each step speaks the same protocol.
That structure maps cleanly onto a lakehouse. A query agent reaches a catalog through MCP, the catalog resolves table metadata, and a compute layer runs the scan and returns rows the agent can reason over. When every layer speaks one protocol, you compose new behavior by wiring servers together rather than writing glue code for each pair.
The payoff is reuse. A well-built MCP server for your governance layer serves every agent in the company, not just one app. Build the data access once, expose it through the standard, and any agent that speaks MCP can use it under the same permissions. That is how a standards layer turns scattered integrations into shared infrastructure.
The Registry and the Trust Problem
Eighteen thousand MCP servers is a big number with a sharp edge. Most of those servers come from the community, and a tool an agent calls is a tool that can misbehave. The official MCP Registry is moving toward general availability with signing and trust scoring, which is the field's answer to a supply-chain risk that grows with every new server.
The risk is real and specific. A malicious tool description can carry a prompt injection that steers an agent off task. A poorly secured server can leak the data it was meant to guard. The registry work aims to give teams a way to check provenance before they wire a server into a production agent. Signed servers and trust scores turn a wild directory into something closer to a package index you can audit.
For data teams, the rule is the same one you already apply to dependencies. Pin what you trust. Review what you add. Treat a third-party MCP server like any other piece of code that touches production data, because that is what it is. The standard makes integration easy, and easy integration is exactly why provenance checks matter.
What This Means for Data Teams
Pull the three threads together and a clear playbook falls out for anyone building data and AI systems. The week rewarded teams designed for change and punished teams built on a single point of failure.
Decouple from any one model. Route agents through an abstraction that lets you swap models without touching prompts or pipelines. Keep at least one tested fallback wired in. Run evals against more than one model so a forced swap does not break behavior you cannot see. The Fable 5 night proved this is not a theoretical concern.
Plan inference placement on purpose. Some work belongs on a 40-TOPS laptop, some on a memory-rich cloud accelerator, and the split is a design choice with real cost and latency effects. Match the model to the chip and the chip to the memory the model needs. A reasoning model with a long context window costs far more on memory-starved hardware than on silicon built for long KV cache.
Build on open standards and open formats. When your data lives in open table formats and your agents reach it through MCP and A2A, no single vendor decision can strand your stack. The model can change, the chip can change, and your data and your access layer stay yours. That portability is the whole point of an open lakehouse, and this week showed why it is worth the work.
The Through-Line: Dependencies You Do Not Control
Step back and the week tells one story across all three areas. Builders depend on things they do not control: a model a government can pull, a chip supply a few firms shape, a protocol a foundation governs. The Fable 5 shutdown was the loudest reminder, but the chip wars and the protocol cycle carry the same lesson. The teams that win in 2026 design for substitution. They wire in fallbacks, they avoid single-vendor coupling, and they build on open standards that let them swap parts without starting over.
That is also the case for an open data foundation. When your data lives in open formats and your agents reach it through open protocols, no single outage and no single vendor decision can take your stack down. The model can change. The chip can change. The data and the standards underneath stay yours.
What to Watch Next Week
Three threads run into next week. First, the Fable 5 status. Anthropic says it is working to restore access and calls the order a misunderstanding. Watch whether the government clarifies its rationale or whether the suspension holds, because the answer sets the precedent for every frontier launch that follows.
Second, the chip response. Nvidia's PC push will draw counters from AMD, Intel, and Qualcomm, who just watched their stock slide. Watch for on-device model announcements that pair with the new laptop silicon, since the hardware needs software to matter.
Third, the protocol cycle. The next MCP spec moves the standard toward stateless cores, Tasks, and server-as-agent composition. Watch the registry's path to general availability with signing and trust scoring, because that is what turns 18,000 community servers into infrastructure you can trust with production data.
The pattern across all three is the one this whole issue keeps circling. Build for change. Own your evals, your data, and your access layer. Treat every model, chip, and vendor as a part you can swap, because this week proved that any of them can change without warning.
Resources to Go Further
The AI landscape changes fast. Here are tools and resources to help you keep pace.
Try Dremio Free — Experience agentic analytics and an Apache Iceberg-powered lakehouse. Start your free trial
Learn Agentic AI with Data — Dremio's agentic analytics features let your AI agents query and act on live data. Explore Dremio Agentic AI
Join the Community — Connect with data engineers and AI practitioners building on open standards. Join the Dremio Developer Community
Book: The 2026 Guide to AI-Assisted Development — Covers prompt engineering, agent workflows, MCP, evaluation, security, and career paths. Get it on Amazon
Book: Using AI Agents for Data Engineering and Data Analysis — A practical guide to Claude Code, Google Antigravity, OpenAI Codex, and more. Get it on Amazon
