DEV Community

Alex Merced
Alex Merced

Posted on

AI Weekly: Opus 5.5, GPT-6 Sol and Luna, and MCPA

Week of September 16 to 23, 2026

Two frontier labs shipped on the same day, and both led with price. Anthropic released Claude Opus 5.5 and OpenAI released GPT-6 Sol and GPT-6 Luna on September 22. Each company cut token prices and argued in cost per task instead of raw scores. Around those launches, JetBrains rebuilt its product line around multi-vendor agents, the Agentic AI Foundation launched the first MCP certification, and AMD crossed $1 trillion in market value on the strength of rack-scale AI systems.

The theme of the week is cost per finished task. Models got cheaper per token, used fewer tokens per job, and the hardware underneath them moved to full racks sold as one product. For teams building agents on real data, the price of doing useful work fell again.

Models: Opus 5.5 and GPT-6 Sol Race on Cost per Task

Claude Opus 5.5

Anthropic released Claude Opus 5.5 on September 22 as the first model in its Claude 5.5 family. The API model ID is claude-opus-5-5. Anthropic says it performs at the level of Claude Fable 5.1 on most work and costs 40% less to run than Opus 5 on typical workloads. It is available on the Claude Platform, Amazon Web Services, Google Cloud, and Microsoft Azure. Anthropic says Sonnet 5.5 and Haiku 5.5 follow in the coming weeks.

Here is the pricing, per million tokens:

  • Input: $4 (down from $5 on Opus 5)
  • Output: $20 (down from $25)
  • Cache reads: $0.20 (down from $0.50)
  • Cache writes: $5 (down from $6.25)
  • Fast mode: $8 input and $40 output, with up to 2.5x speed in Claude Code and the Claude Platform

The cache read cut is the number that matters most for agents. Anthropic notes that cache reads make up most of the cost in agentic and coding work. A long-running agent rereads its context on every turn. A 60% cut on that line item changes the math for anyone running agents all day. Anthropic also reports output generation more than 30% faster than Opus 5.

On benchmarks, all figures below are vendor-reported by Anthropic. Some competitor figures in Anthropic's table come from OpenAI's own reports or from Zapier's leaderboard, as Anthropic notes.

  • Terminal-Bench 4.0 (agentic coding): Opus 5.5 scores 66.4%. Fable 5.1 scores 55.8%, Opus 5 scores 52.3%, and GPT-6 Astra scores 57.9% as reported by OpenAI.
  • FrontierCode v1.1: Opus 5.5 scores 54.4%, against 53.3% for GPT-6 Astra.
  • CursorBench 4.0: Opus 5.5 scores 57.8%, against 41.7% for GPT-5.6 Sol.
  • GDPval-AA v2.1 (knowledge work across 44 occupations): Opus 5.5 scores 1846 Elo, against 1735 for Fable 5.1.
  • AutomationBench (business workflows, run by Zapier): Opus 5.5 scores 40.0%. GPT-6 Astra scores 41.4%.
  • Humanity's Last Exam with tools: Opus 5.5 scores 67.7%.
  • Terminal-Bench-Science 0.1: Opus 5.5 scores 58.7%. GPT-6 Astra scores 64.6%.
  • OSWorld 2.0 (computer use): Opus 5.5 scores 81.8% partial credit.

Two things stand out in that table. Anthropic published rows where GPT-6 Astra wins, on AutomationBench and Terminal-Bench-Science. Anthropic also wrote that benchmark margins at this capability level have become a less reliable guide to real-world differences. That is a fair warning for anyone choosing a model from a leaderboard.

The efficiency claims carry more weight than the scores. Anthropic says Opus 5.5 at default medium effort beats GPT-6 Astra's top FrontierCode score at about a fifth of the cost per task. In an internal test, Opus 5.5 and Fable 5.1 both translated the HAProxy load balancer from C into Rust. Both rewrites passed nearly all of HAProxy's regression tests. Opus 5.5 finished in 9.5 hours against 12 for Fable 5.1, at 51% lower cost. An early tester audited and fixed a 200,000-line codebase in under three hours. Opus 5 took over 20 hours on the same job and used 2.5x the tokens.

Customer reports point the same way. GitHub's Mario Rodriguez said Opus 5.5 used among the fewest tokens and steps his team measured across Copilot CLI and VS Code. Box reported that Opus 5.5 used a third of the tokens Opus 5 did, with answers 40% less verbose. Deloitte reported that at its lowest effort setting, Opus 5.5 caught 72% of known bugs in code review, against 56% for Opus 5 at high effort.

What changes for builders on Opus 5.5

This release carries API behavior changes that matter more than the benchmarks for production teams.

  • Thinking cannot be disabled. Opus 5.5 is no longer available with thinking switched off. Integrations that turned thinking off for latency need to test the new default.
  • Preserved thinking. Anthropic's anti-distillation safeguard stops API users from editing Claude's prior context to extract its reasoning. It applies to Fable 5.1 and Opus 5.5 for API accounts created on or after August 31, 2026. Anthropic published docs on how to test integrations.
  • Safeguard fallbacks. Opus 5.5 ships with safeguards similar to Fable 5.1 for cybersecurity, biology, and distillation. Most cybersecurity tasks reroute to Opus 4.8. Routine bug finding and fixing in your own code still runs on Opus 5.5. Vetted life sciences groups can apply to a verification program for full biology access. Anthropic says an expanded Cyber Verification Program with three access tiers arrives in the coming weeks.
  • Watermarking. Opus 5.5 includes text watermarking to comply with the EU AI Act.
  • Zero data retention remains available, as with prior Opus models.

The fallback behavior deserves attention. If a safeguard intervenes, a different model answers. Teams that audit agent behavior need to log which model served each response, not only which model they requested.

Anthropic also called Opus 5.5 its first release since CEO Dario Amodei argued that AI progress should be paced so safety keeps ahead of capability. External evaluators including METR tested it before release. Anthropic reports Opus 5.5 scored better than any recent Claude model on nearly every measure of its automated behavioral audit, across nearly 2,000 scenarios. In a new containment test, it tried to cross boundaries about 85% less often than Opus 5. Anthropic also disclosed a limit: the model often suspects it is being evaluated, which makes pre-release testing harder to trust.

Subscription users get something too. Anthropic raised five-hour usage limits on Pro, Max, Team, and seat-based Enterprise plans. It also added a rate limit reset that users can save and use when they choose.

Pricing side by side

Token prices only tell part of the story, so it helps to run one example. Take an agent task that reads 2 million cached input tokens, 200,000 fresh input tokens, and writes 50,000 output tokens. That shape is common for a coding agent that rereads a repository context on each turn.

On Opus 5, that task costs $1.00 for cache reads, $1.00 for fresh input, and $1.25 for output. The total is $3.25. On Opus 5.5, the same token counts cost $0.40, $0.80, and $1.00, for a total of $2.20. That is a 32% cut from pricing alone, before any savings from the model using fewer tokens. Anthropic's 40% figure for typical workloads combines both effects.

For OpenAI, the base prices halve across the board. A task that sends 2.2 million input tokens and writes 50,000 output tokens to GPT-5.6 Sol cost $9.80 at list input and output prices. On GPT-6 Sol it costs $4.90 at list prices. Cached input discounts lower both numbers further, so check OpenAI's pricing page for the cached rate before you compare the two vendors head to head.

The practical point: the cheapest model per token is not always the cheapest model per task. Measure tokens per finished task on your own workload, then multiply.

GPT-6 Sol and GPT-6 Luna

OpenAI launched GPT-6 Sol and GPT-6 Luna the same day. They extend the GPT-6 generation that started with GPT-6 Astra earlier this month. Sol targets complex work like coding. Luna targets high-volume tasks with a clear goal, such as summarizing, extraction, and quick answers. Astra stays OpenAI's top model. The API IDs are gpt-6-sol and gpt-6-luna.

The pricing story is blunt. OpenAI cut API prices 50% against the GPT-5.6 promotional rates. The New Stack reports the per-million-token prices:

  • GPT-6 Sol: $2 input and $10 output, down from $4 and $20 for GPT-5.6 Sol
  • GPT-6 Luna: $0.10 input and $0.50 output, down from $0.20 and $1.20 for GPT-5.6 Luna

An OpenAI spokesperson told The New Stack these are the default prices, not a promotion. OpenAI credits better caching and inference for the cut.

OpenAI's headline claims are vendor-reported. On AutomationBench, a Zapier-built test of business workflows across 47 tools, OpenAI says GPT-6 Sol at xhigh effort beats Claude Opus 5 at max effort at 9% of Opus 5's cost per task. GPT-6 Luna at high effort improves on its predecessor by 5.4 points at 58% lower cost per task. On OpenAI's internal factuality evaluation, built from real conversations where users flagged mistakes, GPT-6 Sol makes about half as many errors as GPT-5.6 Sol. The New Stack notes that on DeepSWE v1.1, Sol at max effort scores 68.8% against 69.9% for Fable 5 at xhigh, at about 20% of the cost.

OpenAI's post includes a footnote worth reading. It says its Claude Fable 5.1 datapoint understates Fable's real cost because it omits Opus 5 fallbacks, which occurred on about 40% of AutomationBench tasks. So the safeguard fallback design that Anthropic built into its top models now shows up in a competitor's cost comparison. Expect safeguard behavior to become a routine line item in model evaluations.

GPT-6 Sol and Luna are available in ChatGPT Work and Codex for Plus, Pro, Business, Enterprise, and Edu users. Free and Go users get Luna in the desktop app. Neither model is in regular Chat yet. OpenAI DevDay 2026 runs September 29 in San Francisco.

Qwen3.8-Omni-Flash

Alibaba's Qwen team released Qwen3.8-Omni-Flash on September 18. It is a native omni-modal model that takes text, images, audio, and video as input and returns text. It supports a 1 million token context window. Alibaba reports, as vendor numbers, an average gain of more than 26% across 30 evaluations over Qwen3.5-Omni-Plus.

API pricing on Vercel's AI Gateway listing is $0.15 input and $0.47 output per million tokens. Alibaba did not release weights at launch. The model targets long-video analysis, meeting summaries, and multimodal tool use. Alibaba also shipped Qwen-MM-Plugins and a Qwen-Live Harness for long-running and real-time workflows.

For data teams, the interesting part is the input side. One call can take long audio and video plus a million tokens of context. That turns recorded meetings and support calls into queryable text at a price that makes batch processing practical.

The week in model context

September has been dense. Anthropic shipped Fable 5.1 and Mythos 5.1 on September 1. Google released Gemini 3.8 Flash on September 2. OpenAI released GPT-6 Astra earlier in the month. This week's releases are not new frontiers so much as the frontier getting cheaper. Opus 5.5 claims Fable-level work at Opus prices. GPT-6 Sol claims Astra-level factuality at half the old Sol price.

That pattern favors builders who measure cost per completed task. A model that costs more per token but finishes in fewer steps can come out cheaper. Both labs now publish charts with cost per task on one axis. Use those charts as a starting hypothesis, then run your own workload.

Tooling: JetBrains Air Bets on Many Agents

JetBrains Air

JetBrains introduced JetBrains Air on September 22. The company calls it a system of products for agentic software development. It spans JetBrains IDEs, team delivery workflows, and organizational governance. Unite.AI's coverage notes it brings together six months of public experiments. JetBrains introduced JetBrains Central in March as a control and execution system for agent-driven development, then added a CLI, shared context, cloud agents, automations, governance, and AI cost controls.

The core bet is multi-vendor. JetBrains writes that no single model, agent, or service will be right for every developer, team, or task. Air works with Claude Agent, Codex, Junie, Copilot, OpenCode, and any agent that speaks the Agent Client Protocol. JetBrains says the IDE still matters. It is bringing the base agentic experience into its IDEs so developers can understand, change, and verify what agents produce.

The Agent Client Protocol is the piece to watch. ACP standardizes the connection between an editor and an agent's full harness, including planning, tools, model routing, and observability. JetBrains lists agents that speak ACP, including Junie, Gemini CLI, GitHub Copilot, Codex, Cursor, Mistral Vibe, OpenCode, Kimi CLI, Qwen Code, Factory Droid, Cline, and Kiro CLI. Clients include JetBrains IDEs, Zed, and Neovim through a plugin. An ACP Registry lets developers discover and run compatible agents inside JetBrains IDEs. If ACP holds, an editor stops being tied to one agent vendor.

GitHub Copilot adds GPT-6 Sol and Luna

GitHub added GPT-6 Sol and GPT-6 Luna to Copilot on launch day. GitHub describes Sol as a balanced model for interactive and agentic coding. Luna is the lowest-cost option in the GPT-6 family for smaller, faster tasks. Sol is available on Copilot Pro+, Max, Business, and Enterprise. Luna is available on Pro, Pro+, Max, Business, and Enterprise. Both bill under usage-based billing, and rollout is gradual.

The billing note matters. Usage-based billing means model choice now shows up directly in the invoice. Teams that let every developer default to the most capable model will see it. Teams that route routine work to Luna-class models will see that too.

Claude Code and agent harnesses

On the Anthropic side, Opus 5.5 fast mode is available in Claude Code at $8 input and $40 output per million tokens, with up to 2.5x speed. Early tester reports focus on long unattended runs. Clio's Sean Heintz described handing Opus 5.5 a task across six repositories and letting it run overnight for over 18 hours. Stripe's Cristian Rivera described one Opus 5.5 session directing a dozen more sessions through a multi-day rebase of 40 stacked pull requests, all of which passed CI. AWS's Deepak Singh said Opus 5.5 is coming to Kiro soon. These are vendor-selected quotes, but they describe a clear shift: from one agent in one chat to one agent coordinating many.

Anthropic also points to three security layers for long-running coding agents: a classifier that screens every action before it runs, an open-source sandbox that security teams can audit, and code review that flags vulnerabilities before merge. Anthropic says Opus 5.5 ties Fable 5.1 for the lowest prompt injection success rate on a benchmark run by Gray Swan.

A routing playbook for this week's releases

With four new models in one week, teams need a simple way to decide what runs where. A few patterns follow from the vendors' own positioning.

  • Long, unattended coding jobs fit the top tier of each family. Anthropic positions Opus 5.5 for codebase-wide migrations and audits. OpenAI positions GPT-6 Sol for complex tasks and keeps Astra for the hardest work.
  • High-volume extraction and summarization fit the low tier. OpenAI built Luna for tasks with a clear goal. At $0.10 per million input tokens, it is cheap enough to run across large document sets.
  • Multimodal intake fits omni models. Qwen3.8-Omni-Flash takes long audio and video in one call and returns text that downstream models and SQL engines can use.
  • Everything else belongs behind a router. Gateways like Agent Router, covered below, let platform teams swap models without code changes. That keeps the next price cut a config change instead of a migration.

AI inside open source release processes

A small signal from the Apache mailing lists belongs here. This week, contributors disclosed using Claude, Codex, and GPT 5.6 to verify release candidates for Apache Iceberg, Apache Polaris, and Iceberg C++. One reviewer prompted Claude to check every license in the Iceberg 1.12.0 candidate. It found a bundled cache library with no LICENSE entry, and he voted -1 on that basis. Another used Codex to catch license issues across repeated failed candidates of a Polaris tool.

Apache Iceberg also merged work on AGENTS.md rules for testing, comments, and AI disclosure. Apache Arrow is debating a needs-author-engagement label for pull requests where the author does not engage with review. Open source communities are writing the norms for AI-assisted contribution right now, in public, one thread at a time.

Standards: MCP Gets a Certification and a Conference

The MCPA certification

The Agentic AI Foundation launched the Model Context Protocol Associate (MCPA) on September 14. It is the first official MCP certification and the first certification from AAIF. The exam covers five domains: MCP fundamentals, architecture and components, interactions and execution, security and governance, and use cases and ecosystem. It aligns with the MCP 2026-07-28 specification.

Angie Jones, AAIF's vice president of developer experience, framed it as a shared benchmark for employers. Developers need to understand how agent connections work and how to implement them responsibly, including permissions and trust boundaries. Attendees of the Amsterdam and San Jose conferences get a 20% discount.

AAIF's announcement also shared adoption numbers. Monthly downloads across MCP's Tier 1 SDKs approach half a billion. Both the TypeScript and Python SDKs have passed 1 billion total downloads. MCP tool calls from ChatGPT users reached 98 times their January level by August. Resend passed one million MCP calls in a single month.

AGNTCon + MCPCon Europe

AAIF held AGNTCon + MCPCon Europe at RAI Amsterdam on September 17 and 18. The conference merges AGNTCon, on agent architectures, with MCPCon, on the protocol itself. It also absorbs the European content from the former MCP Dev Summit. The keynotes centered on the MCP 2026-07-28 specification and its move to a stateless core.

That spec, released July 28, is still the story. It brought a stateless protocol core, multi round-trip requests, header-based routing, cacheable list results, authorization hardening, and a formal extensions framework. Before it, a client and server had to hold a session open. Now each request carries what it needs. Requests spread across servers behind a plain load balancer, with no shared session store. That makes a remote MCP server an ordinary HTTP workload that platform teams already know how to run.

The current MCP roadmap takes the next step. Maintainers want one transport model. Streamable HTTP becomes the single binding, carried over stdin and stdout for local servers. Today SDKs maintain two transport pipelines, and protocol metadata is duplicated across HTTP headers and message fields. Collapsing that removes a class of bugs and a lot of SDK code.

The North American edition runs October 22 and 23 in San Jose.

The AAIF stack takes shape

AAIF now hosts six projects: MCP, A2A, AGENTS.md, goose, agentgateway, and Agent Router. A2A joined in August and handles agent-to-agent discovery and delegation. MCP handles agent-to-tool connections. AGENTS.md gives agents a project's rules. Agent Router, formerly Envoy AI Gateway, joined on September 9 and gives developers one OpenAI-compatible endpoint plus MCP endpoints while platform teams manage providers, credentials, quotas, and failover.

Put those together with JetBrains' Agent Client Protocol and the shape of the open agent stack is visible:

  • Instructions: AGENTS.md tells an agent how a project works
  • Editor to agent: ACP connects an IDE to any agent harness
  • Agent to tools and data: MCP
  • Agent to agent: A2A
  • Traffic and policy: agentgateway and Agent Router

Each layer has an open spec and a neutral home or an open protocol. That is good news for anyone who wants to avoid building on one vendor's closed stack.

A2A deserves a closer look now that it sits beside MCP. The protocol lets agents built on different frameworks discover each other, authenticate, and hand off tasks. An agent publishes an Agent Card that describes what it can do and how to reach it. A calling agent sends a task over JSON-RPC 2.0 on HTTPS, and the task moves through a defined lifecycle. Version 1.0, released in March, added cryptographically signed Agent Cards so a caller can verify the card came from the domain it claims. AAIF describes A2A as supported by more than 150 organizations. The move into AAIF changed governance, not the spec. Same site, same SDKs, same technical steering committee.

Agent Router shows the gateway layer maturing. Its project post shows a one-command local start and a single environment variable change to point an existing OpenAI client at the gateway. MCP clients connect to the gateway's MCP endpoint, and the gateway accepts the same mcpServers file that Claude Desktop, Cursor, and VS Code already use. AAIF reports eleven public adopters including Bloomberg, Tencent Cloud, and Nutanix, and nine maintainer seats split across Bloomberg, Nutanix, AMD, Tetrate, and Netflix with no majority holder. Version 1.0 shipped in June with a 1.x compatibility commitment.

Gateways matter for the model news above. When two labs cut prices on the same day, the team with a gateway changes a routing rule. The team with hard-coded provider calls opens a ticket.

The data layer needs standards too

Agents need consistent business meaning, not just tool access. Apache Ossie, an incubating project for open semantic interchange, this week proposed a standard REST API for producing, consuming, and orchestrating semantic models. The proposal names data catalogs such as Apache Polaris as implementers and query engines as clients. Qlik said it has started building an Ossie-native REST API and suggested a dedicated media type, application/vnd.ossie+yaml.

This is the missing piece between MCP and the data. MCP lets an agent call a tool. A shared semantic model tells the agent what "revenue" or "active customer" means, no matter which engine answers the query. An open REST API for those models means catalogs and engines serve the same definitions to every agent.

Infrastructure: Racks, Roadmaps, and Cheaper Serving

AMD crosses $1 trillion on rack-scale systems

AMD crossed $1 trillion in market value on September 21. The Motley Fool notes AMD joins Nvidia, Broadcom, and Micron in that club. Shares rose 23% in the week and are up 187% for the year.

The hardware story behind the stock is Helios, AMD's rack-scale system. Each Helios rack runs 72 Instinct accelerators and 18 EPYC CPUs. The Tech Portal reports the platform combines MI400 and MI450 series GPUs, EPYC Venice CPUs, and Pensando networking. It reports that AMD's data center segment hit $6.72 billion in Q2 revenue, up 107% year over year. Anthropic has committed to up to 2 gigawatts of MI450 GPUs in Helios racks. Meta, OpenAI, and Microsoft Azure are also Helios customers.

Market coverage tied part of Monday's rally to Meta's Muse personal AI agent reaching the top of the U.S. App Store. The argument is that agents that run constantly need CPUs as well as GPUs. Tool calls, retrieval, orchestration, and code execution all run on general-purpose cores. An agent that calls ten tools per task spends a lot of time outside the GPU. That favors vendors who sell both halves of the rack.

For infrastructure buyers, the lesson is about the unit of purchase. The market now prices accelerators, CPUs, networking, and software as one system. Nvidia has sold that way for years with its rack-scale platforms. AMD now does too.

Huawei pulls its Ascend roadmap forward

At Huawei Connect 2026 in Shanghai, Huawei accelerated its AI chip roadmap, according to TrendForce. Rotating Chairman David Wang said the Ascend 960DT is running ahead of schedule and is now expected in the first quarter of 2027, three quarters earlier than planned. The Ascend 960PR follows in the third quarter of 2027. Huawei committed to one generation per year, with the Ascend 970 in 2028 and the Ascend 980 in 2029.

The performance claims are Huawei's own and lack independent validation so far. The cadence is the news. China's domestic accelerator market is building on its own roadmap, with its own chips and its own number formats. Model builders who serve both markets will tune for more than one hardware target.

Serving got cheaper, and the labs said why

Both frontier launches this week included an infrastructure claim. OpenAI said improvements in caching and inference let it serve GPT-6 Sol and Luna at lower cost. Anthropic said Opus 5.5 requires less compute to serve than Opus 5, and that its pricing reflects that. Anthropic cut cache read prices 60%, the largest single cut in its table.

Caching is the quiet infrastructure story of 2026. Agents resend long prompts on every turn: system instructions, tool definitions, and conversation history. Serving that repeated prefix from cache instead of recomputing it saves memory bandwidth and compute. When a lab cuts the cache read price, it is passing along a real serving saving. It also rewards agent designs that keep a stable prompt prefix.

File formats for AI data

Storage formats are infrastructure too, and Apache Parquet had a big week. The Parquet project published its ALP blog post on September 22, after the 2.14 format release added ALP and a FILE type. ALP is an adaptive lossless encoding for floating-point numbers, first published at SIGMOD 2024 by researchers at CWI. Arrow Rust 60.0.0 became the first Parquet implementation to ship ALP support.

Floating-point columns are everywhere in AI workloads: sensor readings, prices, model scores, and embeddings. Better float compression means smaller files and faster scans for those columns.

The Parquet community also opened review on a VECTOR logical type for embeddings and a Modular Footer that lets readers load only the metadata they need. The vector debate is live. One side wants a narrow type built for embeddings, with rules like no NaN values. The other wants a general fixed-size list type that serves tensors too. Whichever side wins, embeddings are on track to become a first-class citizen in the most widely used analytics file format.

The Data Layer: Where Agents Meet the Lakehouse

Cheaper models and stateless MCP make one problem more urgent: agents need safe, consistent access to real data. Three threads from the Apache mailing lists this week show how the open lakehouse is getting ready.

Credentials that fail loudly. Apache Polaris decided that when a client asks for delegated storage access and the catalog cannot provide it, the request fails with a clear error instead of returning a table with no credentials. Agents are the clients that benefit most. An agent that silently receives a table with no credentials often retries, guesses, or falls back to broader permissions. A clear error tells the agent, and the human reviewing its logs, exactly what went wrong. The Polaris team also asked the Apache Iceberg community to clarify the REST spec so every catalog behaves the same way.

Lists that never lie. Polaris also decided that when a catalog caps list sizes, an unpaged request that overflows the cap fails instead of returning a partial list. An agent that lists tables in a namespace and gets half of them has no way to know the list is short. It builds a wrong answer with full confidence. Failing closed protects the agent from its own trust in the data.

Files next to rows. Apache Parquet 2.14 added a FILE type, Apache Arrow is defining a matching extension type, and Apache Iceberg is working out how a governed REST catalog delegates access to those files. Pair that with an omni model like Qwen3.8-Omni-Flash and the pattern is clear. Store references to audio, video, and documents next to structured rows, let the catalog govern who reads them, and let a multimodal model turn them into text that SQL engines can query.

The open agent stack and the open lakehouse stack are converging on the same principles: neutral governance, published specs, and clients that can trust what servers tell them.

Practitioner Takeaways

  • Re-price your agent workloads. Opus 5.5 cut cache reads 60% and GPT-6 Sol cut token prices 50%. Rerun your cost models on real tasks, since both labs claim fewer tokens per task on top of lower prices.
  • Log the serving model. Opus 5.5 and Fable 5.1 fall back to other models when safeguards trigger. Record which model answered each call, not only which you requested.
  • Test the thinking default. Opus 5.5 does not allow thinking to be switched off. Check latency-sensitive paths before you upgrade.
  • Plan for multi-vendor agents. JetBrains Air, ACP, and usage-based Copilot billing all assume you run more than one agent and more than one model. Design routing and cost controls with that in mind.
  • Learn stateless MCP. The 2026-07-28 spec and the new MCPA certification both point to MCP servers as ordinary HTTP services. Build them that way.
  • Watch the data layer. Agents need governed tables and shared semantic definitions as much as they need tools. Open formats like Apache Iceberg and Apache Parquet, open catalogs like Apache Polaris, and emerging semantic standards like Apache Ossie give agents consistent data without lock-in.

What to Watch Next Week

OpenAI DevDay on September 29 will show whether GPT-6 Sol and Luna reach regular ChatGPT and what developer tools come with them. Anthropic says Sonnet 5.5 and Haiku 5.5 arrive in the coming weeks. On the standards side, watch for post-conference MCP proposals from Amsterdam and early sessions for the San Jose AGNTCon in October. On hardware, watch for Helios deployment updates as AMD heads toward its early November earnings report.

Keep Learning

If you want to go deeper on agentic AI, MCP, and the open data stack that agents run on, my books cover it end to end. Find the full catalog at books.alexmerced.com.

Top comments (0)