Week of June 24 to July 1, 2026
This week the AI industry spent less time launching new models and more time reworking how it charges for the ones we have. Cursor and GitHub Copilot both reshaped their pricing. A reported sixty billion dollar deal put a coding startup in the headlines. Four open-weight models made a strong case that you no longer need a closed API to get frontier-quality work. And the Model Context Protocol moved into the final stretch before its biggest release yet, a version that lets AI tools run at scale on plain web infrastructure. Below is what changed, why it matters, and how it connects to the data work many of you do every day.
AI Coding Tools: Pricing Resets and a Sixty Billion Dollar Bet
The story in coding tools this week was money, not models. The capability gap between the top agents has narrowed to the point where the real differences show up on the invoice, and every major vendor is rewriting how that invoice gets calculated.
Cursor splits its team pricing in two
Cursor put a new team pricing structure into effect for renewing customers starting July 1, 2026, and the change reflects how agentic coding actually burns compute. The Standard seat stays at forty dollars per user per month, but Cursor now splits that usage into two separate pools. One pool covers Cursor's own first-party models, including Composer 2.5, run through the Auto mode. The other pool covers third-party models like Claude, GPT, and Gemini routed through their APIs. On top of that, Cursor added a new Premium seat at one hundred twenty dollars per user per month with five times the usage, aimed squarely at developers who run agents all day long. Cursor said the changes lower costs for about ninety percent of teams, according to pricing coverage verified on June 28.
The split matters more than the numbers. For most of the last two years, a coding subscription felt like a flat monthly fee for an assistant. That model breaks down once the assistant becomes an agent that runs for minutes at a time and touches dozens of files. A single long agentic session can eat through a month of budget. By separating first-party model usage from third-party API usage, Cursor makes the expensive part of the bill visible and lets teams decide when to reach for a premium model and when a fast in-house model does the job. The lesson for any team adopting these tools is simple. Watch the meter, not the sticker price. The subscription is now the entry point, not the full cost.
Microsoft's in-house model reaches Copilot Enterprise
GitHub Copilot made its own move this week. Microsoft AI's in-house coding model, MAI-Code-1-Flash, reached general availability for Copilot Business and Enterprise tiers. The Flash model is built for fast, low-latency responses suited to high-volume agentic coding, the kind of repeated small edits that pile up during an agent run. This gives enterprise teams a first-party option for iterative agent sessions instead of routing every request to a third-party model. It arrives on top of the billing overhaul GitHub rolled out on June 1, 2026, which moved every Copilot plan to usage-based billing measured in GitHub AI Credits. Pro includes fifteen dollars in monthly credits, Pro+ includes seventy, and the newer Max tier includes two hundred. Premium model selections draw from that credit pool.
The strategic logic here is worth naming. When a vendor runs its own model, it controls the cost of every token that model generates. Routing high-volume agent work to an in-house model like Flash lets Microsoft keep more of the margin and gives customers a governance-friendly path that does not send code to an outside provider on every keystroke. For enterprise buyers worried about where their source code travels, a first-party model that stays inside the Microsoft stack answers a real concern. The trade-off is that the very best reasoning still often lives in the third-party models, so teams end up matching the model to the task: a fast in-house model for the volume work and a heavyweight model for the hard architecture decisions.
The price of the frontier keeps moving
The backdrop to all of this is a set of hard pricing changes that landed in the days before this week. Access to Anthropic's Fable 5 model through the claude.ai Pro and Max plans ended on June 22, 2026, and Fable 5 became a paid API tier priced at ten dollars per million input tokens and fifty dollars per million output tokens, per pricing coverage from June 28. That is twice the API cost of Opus 4.8 at five and twenty-five. For a long-running agent where the stronger model changes how often a task finishes, the premium can pay for itself. For routine autocomplete and simple refactors, it does not. The teams getting the most out of these tools are the ones tracking spend by feature and adjusting as prices shift, because prices are shifting every few weeks.
A sixty billion dollar signal
The clearest sign of how valuable coding tools have become did not come from a benchmark. It came from a balance sheet. Reporting this week said SpaceX agreed to acquire Anysphere, the company behind Cursor, in a deal valued around sixty billion dollars, according to Tech Insider. If it closes, it will rank among the largest startup acquisitions on record. The number tells you that the tools developers use to write code are now treated as core infrastructure, not productivity add-ons. Anysphere reached that valuation on a revenue climb that saw its annual recurring revenue run from one hundred million dollars in early 2025 to two billion by February 2026, a pace no other business software company had matched in under two years. Whether the deal closes or not, the message to the market is that whoever owns the coding surface owns a large share of how software gets built.
The stack is converging
Underneath the pricing drama, the products themselves are growing more alike. A New Stack analysis from June 26 described Cursor, Claude Code, and OpenAI Codex settling into a shared blueprint made of three layers: orchestration, execution, and review. Rather than one tool winning and the rest dying, the market is forming a composable stack where teams mix an editor-integrated tool for fast edits with an agent for large multi-file work. The economics push in the same direction. Two twenty-dollar subscriptions cover more ground than a single premium seat, so deliberate multi-tool stacks have become the norm.
One quiet convention is doing a lot of the connective work. The AGENTS.md file, a plain markdown file that lives in a code repository and tells an agent how to run tests, what style to follow, and where not to touch, is now read natively by Codex, Cursor, Copilot, and Windsurf. It works like a README written for machines. Because the same file guides every tool, an agent's behavior stays consistent no matter which product a developer opens. That portability is a big deal for teams that use more than one agent, and it feeds directly into the standards story later in this issue.
The three-way race and the human still in the loop
The convergence has reshaped market share. GitHub Copilot's share among professional developers fell from 67 percent to 51 percent over the past year, according to survey data reported in coverage this week. In the JetBrains Developer Ecosystem Survey, the three leaders now sit close together, with Copilot, Cursor, and Claude Code clustered near each other rather than one running away with the market. The picture is a three-way race, not a monopoly. Copilot defends the large base of teams already living inside GitHub. Cursor leads new adoption among developers who want an editor built around agents. Claude Code has become a common choice for heavy agentic work.
None of this removes the human from the job. Roughly 48 percent of AI-generated code carries a security flaw, and most senior developers still review every change before it merges. The work shifts from writing to reviewing, and reviewing now takes up more of a senior engineer's week than writing does. That is the honest state of these tools in 2026. They speed up the typing and change where you spend your attention, but they do not remove the need to spend it. Any team adopting agents should build review and testing into the workflow from day one, cap usage at the team level before a runaway agent session blows a budget, and treat AI output as a draft that a person signs off on.
Anthropic's Cowork window and the June billing change
One promotion running through this week is worth flagging because it ends soon. From June 5 through July 5, 2026, Anthropic doubled the five-hour usage limit for Claude Cowork, its desktop agent for general computer work, at no extra charge for Pro, Max, and Team plans, per coverage from The New Stack. Cowork runs inside the Claude desktop app and can work across local files and applications like Word, Excel, and Chrome to handle multi-step tasks. The doubled window closes on July 5, so anyone wanting to test a desktop agent on real work has a few days left of the larger allowance. Weekly limits did not change, and the five-hour limit returns to normal after the window.
Sitting underneath that promotion is a billing change that took effect June 15, 2026, and it points at where agent economics are heading. Programmatic use of Claude, meaning the Agent SDK, headless mode, and coding agents that run through automated pipelines, now draws from a separate monthly credit billed at API rates rather than counting against a flat subscription. Interactive use, including Cowork and chat, stays inside the subscription. The split reflects a broader industry move. As agents run longer and consume more compute without a human watching each step, vendors are separating the predictable interactive use from the unpredictable automated use and pricing them differently. For teams planning budgets, the takeaway matches the Cursor lesson: the flat subscription no longer captures the real cost of heavy agent work, so track programmatic usage as its own line.
What a team should actually do with all this
Pull the coding-tool news together and a short playbook falls out of it. The pricing resets, the in-house models, the acquisition, and the converging stack all point the same way, so a team can act on the pattern rather than chase each headline.
Start by treating the subscription as a floor, not a ceiling. Cursor's split pools and GitHub's credit meter both say the same thing in different words. The flat fee buys you a seat at the table, and the real cost shows up in how hard your team runs the agents. Pick one person to watch the usage dashboards for the first two months of any rollout, because that is when a runaway agent session or an over-eager automation quietly triples the bill. A cap set at the team level before the rollout starts is cheaper than a surprise invoice after it.
Next, match the model to the job on purpose. A fast in-house model like MAI-Code-1-Flash or Cursor's Composer 2.5 handles the volume work, the small repeated edits that make up most of an agent's day. Save the heavyweight third-party models for the hard calls, the architecture decisions and the tricky debugging where stronger reasoning changes whether the task finishes. Routing every request to the most expensive model is the fastest way to burn a budget with little to show for it.
Then lean into the convergence instead of fighting it. Because Cursor, Claude Code, and Codex now share a three-layer shape and read the same AGENTS.md file, a deliberate multi-tool setup costs little to maintain. Write one clear AGENTS.md that spells out how to run tests, which style to follow, and where an agent should not touch, and every tool your team uses will follow it. That one file does more for consistency than any single product choice.
Finally, keep the human in the review seat. With roughly half of AI-generated code carrying a security flaw, the review step is where quality lives now. Build testing and human sign-off into the workflow from the first day, and treat every agent output as a draft. The teams getting real value from these tools are not the ones that trust the agent most. They are the ones that let the agent type fast and then check its work carefully.
The most important processing story this week was not a new chip. It was the growing evidence that open-weight models, the ones you can download and run yourself, now sit within striking distance of the best closed models while costing a fraction as much to run. A June 27 roundup from OpenRouter, using intelligence scores indexed on June 25, named the four open models that matter most right now. Each one shows a different piece of where model design is heading.
Nemotron 3 Ultra brings a new architecture to open weights
NVIDIA's Nemotron 3 Ultra leads the pack for models built in the United States. It is a 550-billion-parameter model with 55 billion active parameters per token, and its design mixes two architectures: Mamba-2 and a Transformer mixture of experts. The mixture of experts idea keeps costs down by routing each request to a small specialized slice of the network instead of running the whole thing, which is why a model with 550 billion total parameters only activates 55 billion at a time. Nemotron 3 Ultra trained in NVFP4, a four-bit number format, supports a one-million-token context window, and ships under an open license. It scored 48 on the Artificial Analysis Intelligence Index, well ahead of other United States open models and behind only the Chinese-led open frontier. NVIDIA also released more than the weights. It published training data, recipes, evaluation tooling, and reinforcement learning infrastructure.
Two things stand out. First, the four-bit training is a real shift. For years, running a model at four-bit precision meant accepting some quality loss, a compression you applied after the fact to make a big model fit smaller hardware. Models like Nemotron 3 Ultra are now trained with low precision in mind from the start, so four-bit is the intended way to run them, not a degraded fallback. That changes the math on what hardware you need. Second, NVIDIA's motive is easy to read. More open models running in the world means more demand for the chips and software that run them. NVIDIA gains whether you buy its hardware to serve its own model or someone else's. That incentive keeps NVIDIA funding open releases, which is good news for anyone who wants capable models they can run themselves.
MiniMax M3 makes million-token context practical
The second model on the list, MiniMax M3, earns its spot on modality and cost rather than raw score. It is a mixture-of-experts model with roughly 428 billion total parameters and 23 billion active, and it supports a one-million-token context window. Its standout feature is MiniMax Sparse Attention, a technique that makes reading a million tokens far less punishing on compute. Normally, the cost of attention, the mechanism a model uses to weigh how each token relates to every other token, grows sharply as the context gets longer. Sparse attention skips the parts of that calculation that do not matter, so long-context work stops being absurdly expensive. On OpenRouter, M3 runs at a weighted-average price of about ten cents per million input tokens and one dollar twenty per million output tokens, though prices rise above 512,000 tokens of context. On Artificial Analysis's real-world agentic benchmark, it lands roughly level with Claude Sonnet 4.6, which is a strong result for a model you can download.
The practical takeaway for data and engineering teams is that long-context work is getting cheap enough to build on. Feeding an entire codebase, a full set of documents, or a long transcript into a model used to be a luxury priced for special cases. With sparse attention and low per-token costs, it becomes a default option. That opens the door to agents that reason over large bodies of context in one pass instead of stitching together many small queries.
GLM 5.2 and DeepSeek V4 Flash round out the field
The roundup also highlighted GLM 5.2 from Zhipu, which several practitioners called the first open model that feels genuinely frontier-adjacent in daily use, and DeepSeek V4 Flash. GLM 5.2 added a technique called IndexShare that reuses sparse-attention indices across groups of layers to bring down the cost of million-token inference, the same long-context problem MiniMax attacks from a different angle. GLM 5.2 ships under a permissive license, which means teams can run it, fine-tune it, and self-host it without asking anyone's permission. Its main gap is a lack of vision support, so it reads text but not images.
Taken together, these four models tell one story. Open weights have held a steady three-to-six-month gap behind the closed frontier for well over a year, and the frontier labs are not pulling away. For a fixed level of intelligence, the cost keeps dropping as more open models arrive. The number that captures the trend: inference at the quality of GPT-4, which cost around twenty dollars per million tokens in late 2022, now runs near forty cents per million. That is a fifty-fold drop in about three years, and the number of companies offering inference has grown from twenty-seven in early 2025 to roughly ninety by the end of that year. Cheap, capable inference changes what teams build, because the cost objection that used to block an idea has mostly gone away.
What this means for hardware choices
The model news lines up with a hardware reality worth spelling out. The bottleneck in running a language model is memory bandwidth, not raw compute. Generating each token means loading billions of weights from memory into the processor, over and over. That is why so much recent work aims at the memory wall: mixture-of-experts designs that activate fewer weights, sparse attention that skips needless work, and low-precision formats that shrink how much data moves. A model like Nemotron 3 Ultra or MiniMax M3 packs all three ideas together. The result is that capable models now fit on hardware that was out of reach a year ago, from a well-equipped Mac to a modest server, which puts real inference in reach of small teams and not just big labs.
Quantization is now a first-class deployment plan
For readers new to the term, quantization is the practice of storing a model's numbers with fewer bits. A model's weights start as 16-bit or 32-bit numbers. Quantization squeezes them down to 8-bit, 4-bit, or lower, which shrinks how much memory the model needs. A 70-billion-parameter model that needs around 280 gigabytes at full precision fits in roughly 35 gigabytes at 4-bit. The catch used to be quality loss. Squeeze too hard and the model got noticeably worse.
That trade-off is fading. Models now ship trained with low precision in mind, using formats like NVIDIA's NVFP4 or native 4-bit integer weights, so the compressed version is the intended one and quality loss is close to zero. This is the single biggest change in local model deployment this year. It means a developer can run a genuinely capable model on hardware they already own. Tools like Ollama make local serving simple on consumer machines, while vLLM and similar servers handle production self-hosting with techniques that pack many requests onto a single accelerator. A well-equipped Mac with a large unified memory pool can run models that used to require a rack of server GPUs, at single-user speeds that are fine for a solo developer or a small team. For production serving at scale, purpose-built GPU infrastructure still wins on throughput, but the gap for one-user, one-large-model work has narrowed to the point where local inference is a practical weekend project rather than a research undertaking.
More open releases keep landing
The four models OpenRouter highlighted were not the only open releases making noise. Poolside released the weights for its Laguna M.1 model under a permissive license with a 256,000-token context window, described by the vLLM project as a sparse mixture-of-experts model with 225 billion total parameters and 23 billion active. Poolside also showed the model running on Apple Silicon in a 3-bit build at a usable speed on a single high-memory laptop. Smaller models kept the volume up too, with several teams shipping compact coding and retrieval models under open licenses with 4-bit builds and free access through hosting providers. The steady drumbeat matters more than any single release. A new capable open model arriving nearly every week keeps prices falling and gives teams real choice about which model to run for which task.
The economics of inference are the story
Step back and the processing news is really an economics story. Inference, the act of running a trained model to answer a request, is projected to grow into the dominant share of AI compute spending, well past the cost of training models in the first place. That is why so many companies are building specialized chips and why the number of inference providers has ballooned. Competition plus better model designs have driven one of the sharpest cost declines in technology history. The practical effect for a data team is that ideas which were too expensive to try a year ago are now cheap enough to prototype in an afternoon. When the cost of a model call drops fifty-fold, the question stops being whether you can afford to run the model and becomes which open model, at what precision, on what hardware, for which job.
AI Standards and Protocols: MCP Goes Stateless
If coding tools were about pricing and processing was about open models, the standards story this week was about plumbing that will hold up under real load. The Model Context Protocol, the open standard that lets AI systems connect to tools, files, and business systems, is heading into its largest revision since it launched.
The stateless release candidate
The release candidate for the next MCP specification, dated July 28, 2026, is available now, and the final version ships on that date, according to the MCP project blog. The headline change is that MCP becomes stateless at the protocol layer. That word deserves a plain-language explanation, because it drives everything else.
In the current design, a remote MCP server often has to remember things about each client between requests, which is called holding session state. Holding state fights with the way large systems scale. When you run many copies of a server behind a load balancer, a design that spreads incoming requests across those copies, a request that depends on remembered state has to land on the exact copy that holds it. That forces awkward workarounds like sticky sessions and shared session stores. Making the protocol stateless means a server no longer has to remember anything between requests, so you can run it behind a plain round-robin load balancer and scale it out like any ordinary web service. Six specification proposals work together to reach that goal.
A few of the concrete changes make the benefit real. The transport now requires two new headers, Mcp-Method and Mcp-Name, so load balancers and gateways can route a request based on what it is trying to do without cracking open the message body. List and resource results now carry a time-to-live and a cache scope, modeled on the caching rules the web already uses, so a client knows exactly how long a list of available tools stays fresh and whether it is safe to share that list across users. And the protocol now documents how to pass tracing information, so a single request can be followed from the host application through the client, into the MCP server, and out to whatever the server calls next, showing up as one connected trace. These are not glamorous features. They are the features that let a protocol run in production at a bank or a large enterprise.
An extensions framework and a deprecation policy
The release does more than go stateless. It introduces an extensions framework, which lets capabilities like server-rendered interfaces through MCP Apps and long-running work through the Tasks extension ship on their own schedule rather than waiting for the whole spec. It brings authorization closer to the OAuth and OpenID Connect standards that enterprises already run for identity. And it adds a formal deprecation policy, a written promise about how the protocol will change without breaking what you have already built.
That last piece matters for anyone deciding whether to invest in MCP. A protocol that changes fast is exciting and also risky, because a breaking change can force a scramble to keep things working. A written deprecation policy tells implementers what they ship today will keep working tomorrow, which is exactly the assurance enterprises want before they build on a standard. The ten-week window between the release candidate and the final specification is running right now, and it exists so that SDK maintainers and client builders can test the changes against real workloads before the version locks.
The Agentic AI Foundation keeps maturing
MCP does not stand alone. It lives inside the Agentic AI Foundation, a vendor-neutral home under the Linux Foundation that Anthropic, Block, and OpenAI founded in December 2025. The foundation follows the model that made the Linux kernel and Kubernetes durable: no single company controls the direction, and the governance is open. This week the foundation announced the results of its first Ambassador program, a cohort of 138 members across 41 countries, per the foundation's site. An ambassador program sounds like a small thing until you consider what it signals. A standard becomes durable when a global community of practitioners has a stake in it, not just the companies that started it.
The foundation now stewards several projects that fit together. MCP handles how an agent connects to tools. AGENTS.md, the markdown file that guides coding agents, handles how an agent learns a project's conventions, and it is used by more than sixty thousand projects. Goose, contributed by Block, is an open agent. And agentgateway, a unified gateway for agentic AI and MCP, gives enterprises a single control point for security, identity, and observability across their agent traffic. Google's Agent2Agent protocol, which defines how one agent talks to another, also sits under the Linux Foundation. The pattern is a set of open building blocks, each solving one piece of the agent puzzle, governed in the open so no one vendor can lock the ecosystem down.
The scale behind the plumbing work
The push to make MCP stateless and enterprise-ready makes more sense once you see how big the ecosystem has already grown. In under two years, the protocol went from a single company's proposal to a broad standard with real adoption behind it. Public registries now list close to twenty thousand MCP servers, each one a connector that exposes some tool, database, or service to an AI agent. The official software development kits, the libraries that developers use to build MCP clients and servers, pull in tens of millions of downloads a month across languages like Python, TypeScript, and Java. Those are not vanity numbers. They measure how many real projects now depend on the protocol holding steady.
That scale explains the tone of this release. When a standard is small, its maintainers can change it freely, because few people feel the pain. When close to twenty thousand servers and millions of monthly SDK downloads ride on it, every change carries weight. A breaking change ripples out to thousands of projects, and a security gap exposes all of them at once. So the July 28 specification reads less like a burst of new features and more like the work a project does when it grows up. The stateless core, the caching rules borrowed from the web, the tracing support, and the formal deprecation policy are the moves a standard makes when it stops being an experiment and starts being infrastructure that other things depend on.
For a data or engineering team weighing whether to build on MCP, that maturity is the signal that matters. A protocol with this many servers, this much SDK usage, and a written promise about how it will change is a safer foundation than a fast-moving spec with a handful of early adopters. The ecosystem reached the size where stability beats novelty, and this release is the project acting on that fact.
Security is growing up alongside the spec
The push toward stateless, enterprise-ready MCP is happening because the security questions got serious. The National Security Agency published guidance on MCP security in early June 2026, and independent researchers have documented real attack paths, from prompt injection to tools that leak data. MCP reverses the usual pattern, where instead of a client just asking a server for data, a server often acts on the client's behalf. That inversion creates new ways for things to go wrong if the plumbing is loose. The new spec's tighter authorization, its stateless design that reduces session hijacking risk, and the gateway projects that enforce policy at the edge are all responses to those findings. A standard that a year ago was mostly a way to wire up local tools is now being hardened for the kind of production use where a mistake has real cost.
Why This Matters for Data and Analytics Teams
These three threads are not separate. They point at one shift that lands directly on the people who work with data.
Coding tools are becoming agents, and agents need to connect to systems to do useful work. That connection runs through standards like MCP. Open models are getting cheap and capable enough that running an agent over your own data is no longer a research budget line. And the long-context work that sparse attention makes affordable is exactly the kind of work a data agent does when it reads a schema, a set of queries, and a pile of documents to answer a question. Put those together and you get a clear picture of where this is going. The agent writes and runs the query. The standard connects the agent to your catalog and your tables. The open model keeps the cost of all that reasoning low enough to run at scale.
That is why the connective tissue matters as much as the models. An agent that cannot reach your data is a clever writer with nothing to write about. An agent that reaches your data through a fragile, one-off connection is a maintenance headache waiting to happen. The value shows up when an agent can query live data through an open standard, act on what it finds, and do it safely under governance you control. The pricing resets, the open-model progress, and the stateless MCP release are three parts of building toward that world.
For a data team, the near-term reality is more concrete than the big picture suggests. The catalog that tracks your tables, the query engine that reads them, and the governance layer that decides who sees what are the three surfaces an agent has to touch to do useful analytics work. Each of this week's threads makes those surfaces easier to reach. A stateless MCP server that scales like any web service can sit in front of a catalog without becoming a bottleneck. An open model running at low cost can power the reasoning without a runaway inference bill. And a coding agent that reads an AGENTS.md file can learn the shape of your data platform the same way a new engineer does. The pieces are arriving in the order a data team wants them, which is the plumbing first and the polish second. A team that gets its catalog, its access rules, and its query layer in order now will be ready to point an agent at them the moment the rest of the stack settles, and that settling is happening faster than most roadmaps assumed a year ago.
Looking Ahead
A few dates on the near calendar will shape the weeks after this one. The MCP final specification locks on July 28, 2026, which closes the ten-week testing window that is open right now. Between now and then, SDK maintainers and client builders run the release candidate against real workloads and report back, so the version that ships at the end of July reflects what broke and what held during those weeks. Anyone building on MCP should treat the next month as the time to test, not the time to wait.
The Cursor pricing change and the Claude Cowork promotion both hit their marks in the same stretch. Cursor's split pools take effect for renewing teams from July 1, so the first full billing cycles under the new structure start landing now, and teams will see in their own dashboards whether the ninety-percent cost-drop claim holds for their usage pattern. The doubled Cowork window closes July 5, which gives anyone still evaluating a desktop agent a short runway to test it on real work before the larger allowance ends.
On the model side, the pace of open releases shows no sign of slowing. A new capable open-weight model has arrived nearly every week this year, each one pushing capability up or cost down or both. Expect that drumbeat to continue, with more models trained natively at low precision, more sparse-attention designs aimed at long context, and more mixture-of-experts architectures that keep active parameter counts low. The gap between open and closed models has held steady at a few months for over a year, and nothing this week suggests the frontier labs are about to pull away.
The bigger pattern to watch is the one that ties all three sections together. Coding tools are becoming agents. Agents reach data and systems through open standards like MCP. Open models make the reasoning behind those agents cheap enough to run at scale. Each of those threads moved this week, and each one moves again next week. The teams that come out ahead are the ones treating this as a system to build on rather than a stream of announcements to react to. The plumbing is getting solid, the models are getting cheap, and the standards are getting stable. That combination is what turns a year of impressive demos into tools a business can actually run.
Cursor split its team pricing into first-party and third-party pools and added a premium seat, effective for renewing customers from July 1, 2026. Microsoft's MAI-Code-1-Flash model reached general availability for GitHub Copilot Business and Enterprise. Reporting valued a SpaceX acquisition of Cursor's parent company at around sixty billion dollars. OpenRouter named Nemotron 3 Ultra, MiniMax M3, GLM 5.2, and DeepSeek V4 Flash as the open models that matter, each showing how mixture-of-experts designs, sparse attention, and low-precision training keep pushing capability up and cost down. And the Model Context Protocol released the candidate for its July 28 specification, a stateless core that runs on plain web infrastructure, with an extensions framework, tighter authorization, and a formal deprecation policy. The through-line is an industry building the boring, load-bearing pieces that turn impressive demos into systems you can run in production.
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
Top comments (0)