AI Weekly: DeepSeek Cuts Prices as Agents Go Hosted

Week of September 10 to 17, 2026

The first ten days of September belonged to the frontier labs. This week belonged to everyone else. DeepSeek shipped the month's only price cut, Sakana split its orchestrator into a cheap tier and a premium tier, and Shanghai AI Lab dropped a 744B open-weight research agent with almost no fanfare.

The tooling news moved in one direction. OpenAI, Anthropic, and GitHub all shipped features that run agents for you, measure what they cost, and control what they are allowed to do. And at the AI Infra Summit in Santa Clara, Intel CEO Lip-Bu Tan said the memory shortage behind all of this will get worse next year, not better.

Here is what happened, in the usual order: models, tooling, standards, and infrastructure.

Models: DeepSeek V4.1 Flash Resets the Cheap Tier

DeepSeek V4.1 Flash

DeepSeek released V4.1 Flash on September 10. It is the smallest model in a new architecture family, and it ships with native visual understanding. The API model name is deepseek-flash. Weights are on Hugging Face under the MIT license, along with a technical report.

The architecture is the headline. V4.1 Flash is a 552B-parameter mixture-of-experts model built on what DeepSeek calls a causal encoder-decoder design. It activates only 8B parameters when reading input and 16B when generating output. That split matters because agent workloads are input-heavy. A coding agent re-reads the same files and conversation history on every step, so most of its tokens are prefill, not decode.

The second headline is the KV cache. DeepSeek says V4.1 Flash needs one quarter of the high-bandwidth memory (HBM) and one eighth of the SSD storage that the previous generation used for its cache. DeepSeek ties that directly to price, noting that cache-hit charges often make up a large share of agent costs.

The rate card reflects the architecture. According to a tracker that reads each lab's pricing docs, peak rates are $0.30 per million input tokens and $1.20 per million output tokens, down from $0.44 and $1.32 for V4 Flash. The cache read dropped from $0.014 to $0.006, a 57 percent cut. Off-peak rates are half of peak. The same tracker lists a 1M-token context window and 384K maximum output. The official numbers live on the DeepSeek pricing page, and the new rates took effect at 04:00 UTC on September 10.

Benchmarks are vendor-reported. DeepSeek's launch post says V4.1 Flash beats flagship models, including its own V4 Pro, on its benchmark set. The tracker above lists DeepSeek-reported scores of 90.6 on Terminal-Bench 2.1, 74.2 on DeepSWE v1.1, 90.9 on GPQA Diamond, and a 3471 Codeforces rating. None of those have been independently reproduced yet. Terminal-Bench 2.1 is also two major versions behind the Terminal-Bench 4.0 board where GPT-6 Astra and Claude Fable 5.1 were measured earlier this month, so the numbers do not line up with that ranking.

There are breaking changes. DeepSeek retired V4 Flash and V4 Flash Vision Exp. The old model IDs deepseek-v4-flash and deepseek-v4-flash-vision-exp now route to V4.1 Flash for compatibility. DeepSeek's launch post also said that starting at 04:00 UTC on September 14, all deepseek-v4-pro requests were set to route to V4.1 Flash until V4.1 Pro launches. The tracker reports that DeepSeek's API changelog now says V4 Pro service continues past that date in response to user demand. If you pinned V4 Pro, check the changelog before you assume which model is answering.

What it changes for practitioners: The cheapest capable tier just got cheaper on exactly the line that agent loops burn. If you run long agentic jobs on a budget, test V4.1 Flash against your current model with your own evals. Two caveats apply. DeepSeek's peak window follows Beijing business hours, not yours. And a model ID that silently routes to a different model is convenient for migration but bad for reproducibility, so log the model that actually served each request.

Sakana Fugu Max and Fugu Ultra v2

Sakana AI released Fugu Max and Fugu Ultra v2 on September 11. Fugu is not a single foundation model. It is a trained orchestrator that reads a query, builds an agent scaffold on the fly, and routes the work across a pool of open-weight and specialist models, including NVIDIA Nemotron models. Both new versions share one architecture and differ in what they aim at.

Fugu Max targets the best result per dollar. It costs $2 per million input tokens and $6 per million output tokens at any context length, according to DataNorth's summary of Sakana's release post and OpenRouter listings. Fugu Ultra v2 targets the hardest multi-step work. It costs $5 input and $30 output per million tokens, rising to $10 and $45 above 272K tokens of context, per AI/TLDR. Sakana's announcement does not state a context window in the material I reviewed.

Sakana's benchmark claims are its own. Sakana reports that Fugu Ultra v2 scored 48.3 on Chartography, a visual reasoning and data interpretation benchmark, against 27.3 for Claude Opus 5 and 29.5 for Claude Fable 5. Reviewers also cite a vendor-reported 74.3 on DeepSWE for Ultra v2, reached without Fable 5, Fable 5.1, or GPT-6 Astra in its model pool. For Fugu Max, Sakana claims the best overall score on six of ten benchmarks against models in a similar price range, including Terminal Bench 2.1 and GPQA Diamond. DataNorth notes that it is unclear where Sakana sourced the competitor scores this time.

Availability is narrower than a typical API. Both models run through Sakana's OpenAI-compatible API. There are no open weights, and MarkTechPost reports that Sakana does not offer the service in the EU or EEA. Existing Fugu users switch tiers with a one-line parameter change.

What it changes for practitioners: Fugu is a bet that routing beats scale. Sakana also pitches it as insurance against vendor lock-in and revoked API access, since the model pool is swappable. That pitch has real appeal after a summer of access changes across the industry. The trade-off is observability. When an orchestrator picks the model, you need its traces to explain a bad answer, so ask for them before you put Fugu in a production path.

Atria Dawn Preview

The quietest big release of the week came from the Shanghai Artificial Intelligence Laboratory. Atria Dawn Preview is an agentic model built on the 744B-parameter mixture-of-experts GLM-5.2 foundation model. It targets research and engineering work that needs continuous tool use and multi-step execution. The model card describes a full loop: problem analysis, solution design, tool use, code, experiment runs, result analysis, and failure recovery.

The release order was unusual. AI Weekly reports that the Hugging Face repository went live on September 11, with an FP8 checkpoint on September 12, and no blog post or pricing at the time. The weights are MIT-licensed. A formal press release followed on September 15, describing Atria Dawn as an open-source model for long-horizon research agents that turns a published method into runnable experiments, reproducible metrics, and a report that traces conclusions to evidence. The model works inside a control framework and an experimental environment, checks whether its code runs and whether experiments hit their targets, and revises its plan from that feedback.

No first-party per-token price was published. Some routing gateways already list the model, so any price you see comes from a third party. I found no context window or independent benchmark score in the primary materials.

What it changes for practitioners: Atria Dawn is the second open research-agent release in two weeks built on a Chinese base model and published weights-first. The release-before-paper pattern shortens the window between a model existing and a model sitting in someone's pipeline. If your team pulls open weights into production, put an evaluation gate in front of new checkpoints that does not depend on the lab's own report.

GPT-Live-1 comes to the API

OpenAI brought GPT-Live-1 to the API on September 10. It is a full-duplex voice model that listens and speaks at the same time, so it handles interruptions, pauses, and backchannels without the handoff delays of a speech-to-text, LLM, text-to-speech chain. It delegates deeper reasoning and tool calls to a backend model you choose, such as GPT-6 Astra or a third-party model.

Pricing is $0.05 per minute for the voice layer, billed per second, with backend model and tool usage billed separately. OpenAI added 12 new real-time voices. The model provides native transcripts, keyword biasing, and explicit turn detection, and it connects over WebRTC, WebSockets, or telephony and SIP.

The benchmarks are OpenAI's. OpenAI's developer community post says GPT-Live-1 paired with GPT-6 Astra at medium reasoning effort completed 83.6 percent of Tau3 tasks on the first attempt, against 45.7 percent for GPT-Realtime-2.1. The same pairing scored 38.1 percent on TauBanking. OpenAI also claims a 30-point gain on Full Duplex Bench over GPT-Realtime-2.1. One customer quoted in the launch said switching from a cascaded build removed 23,000 lines of code.

What it changes for practitioners: Voice agents now follow the same split as coding agents: a fast front end for the conversation and a slower, smarter back end for the work. OpenAI notes that interrupting speech does not automatically cancel backend work, so your application owns task state and cancellation.

Retirements and deprecations to track

Two dated changes landed this week. OpenAI announced that GPT-5.5 retires from ChatGPT, ChatGPT Work, and Codex on October 14, 2026, across all plans. The API is not affected. Codex users who sign in with ChatGPT should switch to gpt-5.6-sol and update saved settings, custom agents, scheduled tasks, and scripts before that date. Separately, OpenAI deprecated gpt-5.4-cyber on September 11, with removal from the API on October 1, 2026, and gpt-5.6-cyber as the replacement.

OpenAI also retired automatic switching from Instant to Thinking for ChatGPT Plus and Pro users and removed the Higher intelligence setting on the web. Users can still pick a reasoning option manually.

No frontier lab shipped a new flagship this week. After Claude Fable 5.1, Gemini 3.8 Flash, Muse Spark 1.3, and GPT-6 Astra in the first three days of September, a quieter stretch was expected. Google's Gemini 3.5 Pro is still announced without a date.

This week's releases at a glance

Two patterns stand out in that table. First, the two open-weight releases both carry the MIT license, which puts almost no restriction on commercial use. Second, the two Sakana tiers show where the premium sits now. The capability tier costs five times as much on output as the cost tier, on the same API, and the only difference is how hard the orchestrator works. That is the same trade every agent platform is now exposing as a setting, whether it is called effort, tier, or mode.

A note on sourcing. Where a lab's own post did not state a price or context window, this issue cites independent trackers that read the providers' pricing pages. Check the provider documentation before you commit a budget, because several of these rate cards changed more than once in September.

Tooling: OpenAI Launches the Agents API

OpenAI Agents API and hosted sandboxes

OpenAI introduced the Agents API in public beta on September 10. It packages the agent loop behind Codex as a managed service. OpenAI runs the agent loop on its own infrastructure and handles orchestration, long-running sessions, and context management. You define the agent's capabilities and choose where it runs code and works with files.

There is no extra fee for the Agents API itself. You pay for the tokens and tools your agents use at standard rates.

Sandboxes are the other half of the launch. You can bring your own, run in your VPC, or use a partner. OpenAI lists first-class integrations with Blaxel AI, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle Cloud, Runloop AI, and Vercel. OpenAI also launched its own hosted sandboxes, where agents run code, work with files, and produce artifacts. You supply files, install packages, and add skills and plugins, and OpenAI provisions the environment.

The Codex Python SDK moved in step. Version 0.154.0, released September 11, adds max and ultra reasoning-effort values. It also adds ExternalMessage to synchronous and asynchronous run() and turn() calls, so external content can start a turn or join an active one with tool-level authority but without granting user authorization. The release adds include_turns on resume and fork, plus a per-turn service tier.

Check the migrations before you upgrade. HookMetadata now wraps its handler in .root, so hook.command becomes hook.root.command. Some notifications now have typed payloads. And turn handles that attach late only receive events from their attachment point, so collected results can be partial. Custom codex_bin overrides need CLI 0.151.0 or newer for the new features.

OpenAI's Data agent and ChatGPT for Financial Services

OpenAI also introduced a Data agent in ChatGPT Work on September 10. It connects to approved sources including Amazon Redshift, Datadog, Google BigQuery, ClickHouse, Databricks, MongoDB, and Snowflake. It pulls business definitions, metric logic, and relationships from semantic layers and trusted sources such as dbt, GitHub, Databricks Genie Ontology, Snowflake Horizon, and BI dashboards. Queries run with the connected account's existing permissions, including table, row, and column restrictions. The agent builds shareable interactive dashboards and can work inside Omni, Oracle BI, Power BI, Sigma, Tableau, and ThoughtSpot. OpenAI says nearly all of its own product team and over two-thirds of its go-to-market organization use data agents internally.

The same day, OpenAI launched ChatGPT for Financial Services, a tailored ChatGPT Work experience built with design partners Morgan Stanley and Evercore. It includes premium data from Daloopa, PitchBook, LSEG News, and Crunchbase, indexed and hosted by OpenAI, with granular citations back to tables and passages. OpenAI says it tuned the reliability of popular financial MCP connectors, including S&P Global and FactSet, through automated evaluation. Admins can publish Excel, Word, and PowerPoint templates. OpenAI reports GPT-6 Astra at 69.9 percent on OfficeQA Pro against 60.2 percent for GPT-5.6 Sol, a vendor-reported number.

Why this matters for data teams: The pattern here is worth noting. The Data agent does not ask analysts to move data. It connects to where data already lives, respects existing access controls, and reads meaning from the semantic layer. That makes the semantic layer and the governed catalog the most important parts of an agent-ready data stack. Teams with clean metric definitions will get good answers. Teams without them will get confident wrong ones.

Claude Code: plugin evals, effort caps, and gateway headers

Anthropic's Claude Code shipped versions 2.1.265 through 2.1.273 across the week, and the week 37 summary calls out two features. The first is claude plugin eval, added in 2.1.269. It runs a plugin against a suite of test cases, scores the results, and by default reruns each case without the plugin so you can see what the plugin actually contributes. claude plugin eval init interviews you about what a good result looks like, proposes test cases and checks, and writes the files. Anthropic notes that every run and every model-judged check is a real model call on your account.

The second feature lets you pop Claude Code Desktop panes, such as the diff or the terminal, into their own windows.

The changelog is where the admin controls live. Version 2.1.267 added a maxEffortLevel setting, at the top level or per model, that caps effort on every provider, including Bedrock, Vertex, and Foundry. Version 2.1.269 added CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS, which accepts values from 1 to 256, and an option to tag OpenTelemetry metrics with repository attributes. Version 2.1.271 added per-command allowed_domains for Bash, PowerShell, and Monitor in sandboxed auto mode, so each command opens only the hosts it needs. It also added an omitClaudeMd flag for subagents and a modelPricing multiplier of up to 10 for internal chargeback rates.

Version 2.1.273 added opt-in request headers for LLM gateways, enabled with CLAUDE_CODE_GATEWAY_HINT_HEADERS=1. They tell a gateway the request class, agent type, previous tool durations, and whether context was compacted. It also changed auto mode on Bedrock, Vertex, and Foundry to use the local safety classifier by default, with CLAUDE_CODE_AUTO_MODE_SERVER=1 to opt back into the server-side classifier.

A long list of fixes targeted prompt-cache reuse. Several releases fixed cases where resuming a session, switching models, or reconnecting an MCP server rewrote the tool list or system prompt prefix and forced a full cache rewrite. With cache reads now priced far below fresh input across the industry, these fixes translate directly into lower bills for long sessions. Version 2.1.273 also fixed auto-compaction triggering at roughly half the real context window when advisor-tool turns were involved.

Claude Managed Agents and on-demand compaction

On the platform side, Anthropic's release notes list two changes. On September 10, Claude Managed Agents permission policies gained an auto mode. The server evaluates each agent or MCP tool call and runs it, denies it, or pauses for approval, and events now report how each call was evaluated. The ant CLI added ant beta:sessions connect, which attaches your terminal to a live Managed Agents session so you can follow it, send messages, and approve or deny waiting tool calls.

On September 14, the Messages API gained on-demand conversation compaction in beta, behind the compact-2026-09-04 header. You send a top-level compaction parameter, and the API returns a signed compaction block summarizing the messages you sent. On later requests, you send that block in place of those messages. You decide when to compact, the request can run in the background, and you can keep recent turns word for word. On models with preserved thinking, the thinking in kept turns stays valid.

Why this matters: Compaction used to be something each agent framework implemented its own way. A signed, server-generated summary block makes it a first-class API object that any client can store and replay. That is a quiet but real step toward portable agent state.

Anthropic's vertical plugins

Anthropic also shipped three vertical launches. Claude for Financial Advisors arrived September 14 as a Cowork plugin with connectors to Addepar, BlackRock, Charles Schwab, Envestnet, iCapital, Orion, SS&C Black Diamond, Wealthbox, Wealth.com, Vanguard, and Zocks, plus skills for meeting prep, rebalance review, estate and tax briefs, and compliance screening against the SEC Marketing Rule. On September 15, Claude for Small Business expanded to 43 workflows and 27 new integrations, including Shopify, Salesforce, Xero, Gusto, Square, Stripe, and Zapier. Anthropic says the plugin has been installed more than 900,000 times since May. Every workflow starts in approval mode. Also on September 15, Anthropic launched Salesforce in Claude in beta with 37 pre-built sales skills.

Anthropic also launched smart reports in beta for Claude Enterprise on September 10. They analyze how a team uses Claude, what the work costs, where sessions run into friction, and which repeated patterns are worth packaging as shared skills.

GitHub Copilot: cost tiers, ensemble review, and HydraFusion

GitHub had a busy week. On September 14, it added three tiers to Copilot's auto model selection: efficiency, balance, and intelligence. All three draw from the same model set. Auto still evaluates each prompt, so a simple docstring request can land on a small model even in intelligence mode. Billing follows the model auto selects, and paid subscribers keep a 10 percent discount on usage billed through auto. The tiers are rolling out in VS Code, Copilot CLI, and the GitHub Copilot app.

On September 11, GitHub updated Copilot code review. Copilot now resolves its own comments when a later commit addresses them, writes commit messages when you apply its suggestions, and validates code with the full set of shell tools from the Copilot SDK behind the agent firewall. The Lite effort level now uses an ensemble of agents. GitHub reports that the ensemble raised addressed comments per review by 47 percent for high-severity findings, 31 percent for medium, and 11 percent for low, while cutting review cost by about 8 percent.

The September 7 weekly release post, published September 10, introduced Project HydraFusion in the Copilot CLI's /experimental menu. HydraFusion routes each task between local, cloud, and compound models to balance performance, cost, and latency, and you select it like any other model. The same post covered Jira integration in the Copilot app, scheduled agent automations and an experimental voice mode in VS Code 1.137, and centrally managed sandbox policies for Copilot in JetBrains.

The Copilot CLI shipped several builds. Version 1.0.84-5 added session and memory import commands for a semantic JSONL interchange format, moved command parsing to a Rust grammar, and made /usage show per-model AI Credit consumption. Version 1.0.84-6 added a /config screen and network allow and deny rules in /sandbox, and fixed a bug where MCP tools with certain boolean schemas caused 400 errors on Gemini. It also fixed COPILOT_ALLOW_ALL so that falsey values disable automatic tool approval instead of enabling it. That last fix is worth a second look if you set that variable in CI.

GitHub also added VS Code Agents window metrics to Copilot usage reports and released REST APIs in public preview for enabling AI Scan for pull requests at the organization and repository levels.

The pattern across vendors

Put these launches side by side and the direction is plain. OpenAI's Agents API, Anthropic's Managed Agents auto policies, and GitHub's HydraFusion and auto tiers all move two decisions from the developer to the platform: where the agent runs and which model does each step. In exchange, every vendor is adding controls. Effort caps, per-command network allowlists, server-evaluated tool calls, usage reports by model, and plugin evals all exist so an administrator can see and bound what the platform decides.

That is the right trade for most teams. It also means your cost and quality now depend on routing logic you did not write. Measure it. Plugin evals, per-model usage reports, and gateway hint headers are the instruments. Use them before you trust the defaults.

Standards: A Quiet Week for Protocols, a Busy One for Formats

No new MCP or A2A release

There was no new Model Context Protocol specification release this week and no new Agent2Agent (A2A) release. The latest MCP spec is still the 2026-07-28 version, which made the protocol stateless, and the most recent MCP blog post is the updated roadmap from August 22. A2A's latest milestone was its acceptance as a Growth Stage project at the Agentic AI Foundation (AAIF) in late August. If you track these specs, the next big date is AGNTCon+MCPCon, which the AAIF lists for October 22 and 23 in San Jose.

A quiet spec week is not a quiet implementation week. MCP fixes showed up across this week's tooling releases. The Copilot CLI now notifies MCP servers when a tool call is cancelled, requests extra OAuth scopes when needed, and fixed a schema bug that broke some MCP tools on Gemini. Claude Code added a notification when an MCP server disconnects and reconnection gives up, and fixed MCP OAuth client registration bugs. OpenAI's financial services launch describes automated evaluation to raise the reliability of popular MCP connectors. The protocol is stable enough that the work has shifted to making clients and servers behave well at the edges. For teams running MCP servers in production, that is good news. Cancellation, re-authentication, and disconnect handling are where real deployments break, and the major clients are now fixing those paths release by release instead of waiting on the spec.

Portable agent state is becoming a format question

Two tooling changes this week point at a standards gap. GitHub's Copilot CLI added import commands for a semantic JSONL interchange format covering sessions and memory. Anthropic's Messages API now returns a signed compaction block that stands in for earlier conversation turns. OpenAI's Codex SDK added history selection on resume and fork.

Each vendor is defining how agent sessions, memory, and summaries get stored and replayed. None of these are shared formats yet. MCP standardized how agents reach tools. A2A standardized how agents talk to each other. The next interoperability fight is over how an agent's accumulated state moves between tools and vendors. Watch for proposals in that space.

Open semantic models: Apache Ossie

The most concrete standards news for data teams came from the Apache Ossie (incubating) dev list, which covers an open specification for semantic models. Microsoft's Power BI group asked the community for guidance on announcing its commitment to Ossie at the upcoming Fabric Community Conference. The group plans to build a converter between Power BI semantic models and Ossie and contribute it to the project.

Ossie also moved on its core format. Yufei Gu proposed that each Ossie document hold exactly one semantic model, with its fields at the root, and opened a follow-up PR to update the converters. Jean-Baptiste Onofré confirmed that the first release, 0.3.0, will focus on release mechanics and a full legal check. And Marco Ciavarella proposed a dedicated channel for field reports written by coding agents that build with the spec.

This connects directly to the tooling section. OpenAI's Data agent reads meaning from semantic layers. Every agent that answers business questions needs metric definitions it can trust. An open semantic model format that BI tools, catalogs, and agents all read is what makes those definitions portable instead of locked inside one vendor's product.

Data format standards: Parquet 2.14 and the versioning debate

Parquet had a significant standards week too. The Parquet Format 2.14.0 release vote passed on September 11, bringing the ALP floating point encoding and the FILE logical type into the spec. A separate vote approved Extended Precision Nanosecond Timestamps.

The larger debate is about how readers should handle unsupported format versions. Ryan Blue, Fokko Driesprong, Xiening Dai, and Kurtis Wright favor a strict rule: a reader must fail on a file written with a format version it does not support. Andrew Lamb and Will Edwards argued for letting readers attempt the read, as most do today. The strict option makes it easier to ship breaking improvements such as a lighter footer. It also means every engine in a stack has to upgrade its Parquet reader before writers turn on new features.

Parquet is the storage layer under most AI training data pipelines, feature stores, and lakehouse tables. How it versions is an AI infrastructure question as much as a data engineering one.

Iceberg REST catalog and multimodal access

On the Apache Iceberg list, Sung Yun opened a discussion about access delegation for the proposed FILE type, which lets a table column reference external objects such as images and documents. The use case is multimodal inference: a service outside the query engine needs to fetch those objects. The proposal adds client-requested pre-signed URLs to the REST catalog spec. Daniel Weeks and Prashant Singh pushed to align it with existing pre-signed URL work before anything lands. This is the open table format community designing for AI workloads directly, and it belongs on the radar of anyone building retrieval over files in a lakehouse.

Infrastructure: Memory Is Still the Wall

Intel says the memory crunch gets worse in 2027

The clearest infrastructure signal of the week came from the AI Infra Summit in Santa Clara, which runs September 15 to 17. Intel CEO Lip-Bu Tan warned there that the memory shortage will be worse in 2027 than in 2026. Fudzilla reports that Tan said memory prices have risen five to seven times, and that memory now makes up 70 to 80 percent of the component cost of some low-end phones and laptops. Invezz reports that Tan also flagged electricity and cooling as emerging constraints.

A separate report from Aroged, citing a Splunk broadcast appearance, says Tan acknowledged Intel cannot meet more than half of demand for its processors, does not expect memory to improve until 2028, and plans to start 14A production in the first quarter of 2027. These are secondhand accounts of spoken remarks, so treat the exact figures with some care. The direction is consistent across every report.

The cause is structural. Memory makers are steering wafer capacity toward HBM for AI accelerators, which leaves less for commodity DRAM and NAND. DIGITIMES' weekly roundup for September 7 to 13 describes HBM4 and server demand straining DRAM and NAND supply, alongside Intel CPU price increases.

What it means for AI teams: Memory is now the price floor for both training and inference. It shapes GPU availability, server costs, and even the laptops your developers use. Plan 2027 hardware budgets with higher memory costs baked in, and treat any software change that cuts memory use as a cost reduction.

Software is attacking the memory problem directly

That last point is exactly what DeepSeek did this week. V4.1 Flash's KV cache needs one quarter of the HBM and one eighth of the SSD storage of the previous generation. The KV cache holds the attention state for every token in context, and on million-token contexts it often consumes more accelerator memory than the model weights. Shrinking it lets a provider serve more concurrent requests on the same GPUs, which is how DeepSeek was able to cut prices during a memory shortage. DeepSeek also invited teams planning deployments of 2,000 GPUs plus a storage cluster to contact it directly.

The architecture choice works the same way. Activating 8B parameters for input and 16B for output means prefill, the input-heavy half of agent workloads, runs on a much smaller slice of the model. Expect other labs to publish similar input and output splits as agentic workloads dominate inference traffic.

OpenAI's GPT-Live-1 is a different angle on the same economics. A single full-duplex model replaces a three-stage speech pipeline, which cuts both latency and the number of models held in memory per conversation. At $0.05 per minute for the voice layer, it pushes the heavy reasoning to a backend model that only runs when the conversation needs it.

Columnar formats keep getting smaller

The storage side of AI infrastructure also moved. Apache Arrow Rust 60.0.0 passed its release vote on September 15. Release manager Andrew Lamb said arrow-rs is the first Parquet implementation to include the new ALP encoding for floating point data. The release also adds new Parquet PageIndex structures and many performance improvements. The crates are live on crates.io.

Float and double columns are everywhere in AI data: embeddings stored as arrays, model features, sensor readings, and evaluation metrics. General-purpose encodings compress them poorly. ALP targets exactly that data, and it now ships in the Rust parquet crate that DataFusion, iceberg-rust, and many other Rust engines depend on. Implementations in C++, Java, and Go are in review, according to the Parquet community sync notes. The same notes record progress on a vector logical type for Parquet, which targets embedding storage directly.

Accelerators at the AI Infra Summit

NVIDIA's AI Infra Summit event page promotes a keynote from Ian Buck, NVIDIA's VP of Hyperscale and HPC Computing, on infrastructure for agentic AI. The page describes Groq 3 LPX as an interactive inference accelerator that extends the Vera Rubin platform, aimed at fast token generation for responsive agent systems. Converge Digest's summit preview frames the event around scale-up interconnect, scale-out networking, and scale-across data center links, with Google Fellow Dave Patterson, Ian Buck, and Lip-Bu Tan on the main stage. The summit runs through September 17, so expect more detailed announcements to surface in next week's coverage.

Practitioner Takeaways

Run the cache math before you switch models

Rate cards hide the number that matters most for agents. Here is a worked example using DeepSeek's published peak rates. Take one long agent run that reads 10 million cached input tokens, 1 million fresh input tokens, and writes 200,000 output tokens.

On V4 Flash at $0.014 cached, $0.44 input, and $1.32 output per million, that run costs $0.14 plus $0.44 plus $0.264, or about $0.84. On V4.1 Flash at $0.006, $0.30, and $1.20, it costs $0.06 plus $0.30 plus $0.24, or $0.60. That is a 29 percent cut, and more than a third of it comes from the cache line alone.

Now change the shape. A chat workload with little caching and a lot of output saves far less, because output only dropped 9 percent. The lesson applies to every vendor: pull a week of real traffic, split it into cached input, fresh input, and output, and price that mix. Headline input prices tell you very little about an agent bill.

Five things to do this week

• Audit pinned model IDs. DeepSeek now routes old IDs to a new model, and OpenAI has two retirement dates in the next four weeks. Log which model actually served each request so a silent swap shows up in your dashboards.
• Set effort and concurrency caps. Claude Code's maxEffortLevel and workflow concurrency limit, and Codex's new max and ultra effort values, give you both more power and more ways to overspend. Decide your ceilings on purpose.
• Evaluate plugins and skills like code. claude plugin eval runs each case with and without the plugin. Use that comparison to delete plugins that add tokens without adding quality.
• Check your CI environment variables. The Copilot CLI fix for COPILOT_ALLOW_ALL changed how falsey values behave. If your pipelines set it, confirm the behavior you expect.
• Invest in your semantic layer. OpenAI's Data agent, Apache Ossie, and Polaris' new semantic model privileges all point the same way. Agents answer business questions only as well as your metric definitions allow.

Where the week leaves the stack

Three layers moved at once. Models got cheaper per task through architecture, not just discounts. Platforms took over the agent loop and added the controls to supervise it. And the data layer kept adding the pieces agents need: compact float encodings, vector types, governed semantic models, and catalog-level access for multimodal files. None of those layers works well alone. The teams that get the most from this week's releases will be the ones that treat model choice, agent platform, and data architecture as one design problem.

What to Watch Next Week

• DeepSeek V4 Pro routing. Confirm whether deepseek-v4-pro requests are served by V4 Pro or V4.1 Flash, and watch for V4.1 Pro.
• Independent benchmarks. Look for third-party scores on DeepSeek V4.1 Flash, Fugu Ultra v2, and Atria Dawn Preview. Every number in this issue for those models is vendor-reported.
• Gemini 3.5 Pro. Google has announced it with no date or price.
• AI Infra Summit follow-ups. Detailed accelerator, memory, and networking announcements from Santa Clara.
• Parquet versioning. A decision on strict reader version checks will shape how new footer and encoding features roll out.
• Deadlines. gpt-5.4-cyber leaves the OpenAI API on October 1, and GPT-5.5 leaves ChatGPT and Codex on October 14.

Resources to Go Further

The tools change every week, but the fundamentals of data, lakehouse architecture, and agentic AI hold steady. I have written books on all of it, from Apache Iceberg and Apache Polaris to AI-assisted development and AI agents for data work. You can find every title at books.alexmerced.com.