The Best AI Features We've Seen This Month

What This Month Tells Us

Before the feature-by-feature breakdown: step back and look at what everything released in the last few weeks actually signals.

The clearest signal is that the industry has quietly stopped arguing about whether AI can do the work and started arguing about how much of it humans should see. Anthropic ships dynamic workflows capped at 1,000 parallel subagents. Google rewires its developer platform around agent orchestration. OpenAI makes its voice reasoning model available to anyone with an API key. The question is no longer “can the model reason?” — it’s “how do we give users control over a system that can now run hundreds of tasks in parallel without them watching?”

A second signal: the surface area is collapsing. Canvas shipped out of ChatGPT because writing blocks embedded in chat are good enough. Copilot’s model picker replaced a thousand configuration options with two buttons. Gemini Omni replaced separate image, video, and audio models with one. The era of building five specialized tools is ending. The era of one tool that handles whatever you throw at it — and has opinions about how to present the result — is here.

Third signal, and the one most builders should pay attention to: the productivity tools that are winning are winning on integration depth, not model quality. Zoom’s AI works better not because it has a better model than alternatives, but because it’s already in the meeting. Copilot is embedded in Teams, OneDrive, and Outlook. Perplexity Computer connects to Slack, Salesforce, and Google Drive. Distribution beats intelligence at the product layer, and that gap will widen.

Now the features.

1. Claude Code Dynamic Workflows — Anthropic

What it is: Dynamic Workflows lets Claude Code orchestrate up to 1,000 parallel subagents in a single session. You describe the task, Claude writes orchestration scripts on the fly, fans work out across agents running in parallel, checks results before surfacing them, and only keeps the final answer in its context — not every intermediate state.

Why it’s interesting: The architecture decision is the product decision. By keeping only final results in context (not all intermediate agent state), Anthropic sidestepped the context-bloat problem that kills most multi-agent systems at scale. The system is capped at 16 concurrent agents and 1,000 total per run — explicit constraints that prevent runaway cost and give users predictable billing.

The real-world proof point is striking: Bun founder Jarred Sumner used dynamic workflows to port 750,000 lines from Zig to Rust, with 99.8% of the existing test suite passing, completed in eleven days. That’s not a demo. That’s a shipped migration.

What builders can learn: If you’re building multi-agent orchestration, the hardest problem isn’t parallelism — it’s context budget management. Design the context as a first-class constraint from the start, not a cleanup problem you solve later.

2. GPT-Realtime-2 — OpenAI

What it is: OpenAI’s updated real-time voice model, launched May 8, 2026. GPT-5-class reasoning in live spoken conversation. 128K context window (4× its predecessor). Adjustable reasoning effort levels: minimal, low, medium, high, xhigh. Parallel tool calls during conversation. Native interruption handling without context loss.

Why it’s interesting: The reasoning effort toggle is the feature that matters most here. Every voice AI product has to make a tradeoff between latency and intelligence. Previously, developers had to choose a model and live with that tradeoff. GPT-Realtime-2 lets you tune it per conversation — or per utterance if you build around it. Customer support? normal. Debugging a complex data pipeline via voice? xhigh. That’s a meaningful design primitive.

The pricing is steep ($32/million audio-input tokens, $64/million audio-output tokens), which prices most consumer apps out of the market. But for enterprise voice agents where call resolution rate matters more than per-call cost, the intelligence jump is worth modeling.

What builders can learn: Expose the latency-vs-depth tradeoff to users. Not as a technical setting, but as a product signal — “working harder on this” is something users can understand and appreciate. The model now supports it natively; the product layer just needs to surface it.

3. Gemini Omni — Google

What it is: Announced at Google I/O 2026, Gemini Omni unifies text, image, audio, and video generation in a single model. It accepts any combination of inputs and reasons across all of them to produce a consistent output. The initial rollout (Gemini Omni Flash) focuses on video generation and editing — available through the Gemini app, Google Flow, and YouTube creation surfaces.

Why it’s interesting: Every other top-tier AI system uses separate specialized models for vision, audio, video, and text and stitches them together via routing logic. Omni is genuinely unified — the model reasons across modalities rather than passing outputs between models. This matters for quality (consistency across modalities) and for latency (no sequential pipeline), but more importantly it matters for product simplicity. Builders don’t need to orchestrate separate models for different input types.

The safety decision is notable too: all Omni-generated video includes Google’s SynthID digital watermark. That’s a provenance layer baked into the product from day one, not added as an afterthought after a deepfake scandal.

What builders can learn: Multimodal UX is still largely unsolved at the product layer — most interfaces still assume one input type at a time. If your users could describe a problem with their voice, show you a video of it, and receive a structured answer, what would that unlock? The model can now do it. The interface probably can’t yet.

4. Google Antigravity 2.0 — Google

What it is: Google’s agent-first development platform, upgraded significantly at I/O 2026. The package includes a standalone desktop app for orchestrating coding agents, the Antigravity CLI (renamed from Gemini CLI), the Antigravity SDK for programmatic access, and Managed Agents in the Gemini API — which spins up a full isolated Linux environment with persistent state via a single API call.

Why it’s interesting: The Managed Agents feature is the most underrated part of this launch. The proposition — one API call, full sandboxed Linux environment, persistent across multi-turn sessions — removes a lot of the scaffolding that teams currently build themselves when deploying agents to production. You’re not managing containers or state serialization; you’re calling an endpoint.

The AGENTS.md / SKILL.md conventions are also worth paying attention to. Rather than complex orchestration code, you define agent behavior in markdown files. It’s opinionated, but the opinionation is useful: it makes agent behavior legible to the whole team, not just whoever wrote the orchestration layer.

One honest caveat: early reviews flagged a rocky launch. The CLI transition from Gemini CLI caused friction for teams already integrated. Adopt with that in mind.

What builders can learn: The infrastructure layer for agents is consolidating fast. If you’re hand-rolling sandboxed execution environments for your agents, model the build-vs-buy tradeoff against Managed Agents. The undifferentiated work is getting commoditized quickly.

5. Claude Opus 4.8 Uncertainty Flagging — Anthropic

What it is: Not a headline feature, but one of the more important model behavior changes in this cycle. Claude Opus 4.8 is around four times less likely than its predecessor to let code flaws pass without comment. It proactively flags uncertainties about its own work and is less likely to make unsupported claims during agentic tasks.

Why it’s interesting: Model honesty at the behavioral level is genuinely harder to get right than model capability. A model that confidently produces wrong output is more dangerous than a model that is explicit about its uncertainty, especially in agentic contexts where the output feeds downstream tools or actions. Anthropic has shipped this as a measurable behavioral change, not just a safety marketing claim.

The concurrent release of effort controls on claude.ai — letting users specify how much work Claude should put into a task — is the product-level complement to this. More effort, more scrutiny. Less effort, faster draft. That’s a UX mental model users actually have.

What builders can learn: If you’re building on top of any foundation model, uncertainty surfacing should be a first-class design requirement. “I’m not confident in this part” is load-bearing information for any user who needs to act on AI output. Build the interface to show it.

6. Microsoft Copilot GPT-5.2 Mode Selector

What it is: Microsoft 365 Copilot now lets users choose between Quick Response and Think Deeper modes when using GPT-5.2 in Copilot Chat. Quick Response is optimized for speed. Think Deeper runs higher-capacity reasoning and takes several seconds longer, returning structured, stepwise answers. The same model, two deliberate tradeoff options.

Why it’s interesting: This is a UX pattern more teams should steal. The model selector is not about capability differentiation — it’s about surfacing the latency-vs-depth tradeoff in terms users can reason about. “I want this fast” vs. “I want this thorough” is a decision most knowledge workers already make mentally. Making it explicit in the UI lets the product serve both modes without confusion.

The broader Copilot 2026 update also includes Glance Cards in search results, collaborative agents in Teams meetings, and an in-app image editor for PowerPoint. Most of this is incremental deepening of existing integrations, not new capability — which is exactly the right strategy for an enterprise productivity tool that needs adoption across thousands of organizations with different workflows.

What builders can learn: Not every user wants the same tradeoff every time. Designing a visible, simple toggle for latency vs. depth is often more valuable than picking the “best” default. Users who understand the toggle use the product more confidently.

7. GitHub Copilot Agent Mode Coordination Dashboard

What it is: GitHub’s desktop experience now lets developers coordinate multiple AI coding agents simultaneously — not just one Copilot session, but several agents running in parallel on different tasks within the same project. The dashboard surfaces agent progress, lets you intervene on any of them, and aggregates the results.

Why it’s interesting: Copilot’s benchmark score on SWE-bench is 56% — higher than Cursor’s 51.7%. But Cursor completes each task approximately 30% faster (62.9 seconds vs 89.9 seconds). What the coordination dashboard changes is the unit of comparison. When you can run five agents in parallel, raw task completion time per agent matters less. You’re managing a fleet, not a pair programmer.

The design question this raises — which the dashboard directly addresses — is: what does the human actually need to see when multiple agents are running? Not all intermediate steps. Not all generated code. The human needs progress signals, confidence indicators, and intervention points. GitHub’s bet is that they can make that legible at scale.

What builders can learn: Multi-agent UX is going to be one of the defining design problems of the next two years. Start thinking about it now: what does a user need to trust a fleet of agents, without watching every step? That’s a harder problem than building the agents themselves.

8. OpenAI GPT-5.5 Writing and Code Blocks (Canvas Removal)

What it is: OpenAI removed Canvas from GPT-5.5 Instant and GPT-5.5 Thinking. Writing and coding functionality are now handled directly in chat via writing blocks and code blocks. The canvas editor was a separate surface; it’s gone from these models. Paid users can still access it via legacy models until those are sunset.

Why it’s interesting: This is a product bet worth examining carefully. Canvas was a differentiated surface — it gave writers and coders a dedicated editing environment with version history and focused tools. OpenAI removed it because, evidently, embedded blocks in chat are good enough for most users. The data presumably backed this up.

The signal for product builders is the follow-on question: what surfaces are you maintaining that users don’t actually need? Canvas removal is a simplification driven by usage data, not a capability reduction. Teams often keep separate UX surfaces alive because they represent previous investment, not because users use them. This is a case study in cutting clean.

What builders can learn: Audit your surface area. Every modal, separate editor, and specialized panel is a place users can get lost. If a core workflow can happen inline, it usually should.

9. Perplexity Computer — Search as Multi-Model Orchestration

What it is: Perplexity Computer is the company’s answer to the question of what happens when you take an AI search product and extend it into a full orchestration system. It can orchestrate across 19 models in parallel, matching each task to the best available model. Research, code, deploy, and manage from a single conversation interface. It ships with deep integrations: Google Drive, SharePoint, Dropbox, Salesforce, HubSpot, Slack, and 100+ others.

Why it’s interesting: Perplexity’s original product insight — synthesize answers from multiple web sources and cite them inline — was fundamentally about trust through legibility. Computer extends this to task execution. The multi-model orchestration is interesting technically, but the product insight is that users shouldn’t care which model did which part. They should care about whether the answer is right and where it came from.

The preload deal on Samsung Galaxy S26 — making Perplexity the first non-Google company to get OS-level access on a Samsung device — is the distribution move that will matter more than any model improvement. Reach beats quality at scale.

What builders can learn: If you’re building agentic workflows, the integration layer is the moat. The ability to touch the user’s actual data — their Drive, their Slack, their CRM — is what makes an agent useful vs. impressive. Plan your integration roadmap alongside your model roadmap, not after it.

10. Zoom ZoomMate — Meeting-Embedded Decision Intelligence

What it is: ZoomMate, launched June 1, 2026 at $20/user/month, integrates AI directly into live meetings and connects meeting decisions to platforms including Salesforce, Jira, ServiceNow, and Slack. It operates during the meeting — not as a post-meeting summary tool — and can surface relevant data from connected platforms mid-conversation.

Why it’s interesting: Most AI meeting tools are async: they record, transcribe, and summarize after the meeting ends. ZoomMate is synchronous — it’s in the room. The value proposition is not “you’ll get better notes later” but “you’ll make better decisions now because you have the right context during the conversation.” That’s a fundamentally different product.

The integration with task management and CRM systems is what makes this more than a novelty. When ZoomMate can surface the relevant Jira ticket or Salesforce opportunity during a live conversation about it, the meeting has tighter feedback loops with the systems of record. That’s genuine workflow value, not demo value.

What builders can learn: Synchronous AI features (in the moment) often have more perceived value than async ones (after the fact), even if the technical capability is similar. If your users are doing anything in real-time — meetings, customer calls, live debugging — there’s likely an embedded AI opportunity you haven’t explored yet.

11. Gemini Live API Native Audio (Vertex AI)

What it is: Google’s Gemini Live API on Vertex AI, powered by Gemini 2.5 Flash Native Audio, moves voice agent architecture from multi-stage pipelines (ASR → LLM → TTS) to a single, real-time, unified processing layer. One model handles audio, text, and visual inputs simultaneously. It processes raw audio, including tonal and emotional cues, natively.

Why it’s interesting: The technical architecture change (unified vs. pipeline) has real product consequences. Pipeline systems introduce latency at every stage and lose nuance in the handoffs — the speech recognition throws away tonal information before the LLM ever sees it. Native audio processing means the model can interpret tone, emotion, and pacing as part of the response generation, not as a separate step.

The “affective dialogue” capability — where the model interprets emotional state from audio and adjusts its response accordingly — is the detail that distinguishes this from purely technical. An agent that can notice stress in a voice and de-escalate is qualitatively different from one that just converts speech to text and responds to words.

What builders can learn: If you’re building voice agents today using a stitched pipeline, prototype against native audio models. The quality difference in emotionally charged conversations — which is most customer-facing scenarios — is material.

What This All Means

A few threads worth naming explicitly.

Agents are crossing from demo to infrastructure. Dynamic workflows, Antigravity Managed Agents, and GitHub’s coordination dashboard all ship this month as production-grade features with real cost controls and capacity limits. The question has shifted from “can we show this working?” to “can we run this reliably at scale?”

The simplification wave is real. Canvas out of ChatGPT. Two modes instead of model configuration in Copilot. One Omni model instead of four specialized ones. Every major platform is reducing surface area, not expanding it. This is a maturing market signal — when products get simpler, they’re confident in their core loop and shedding everything else.

Voice is finally a first-class API primitive. GPT-Realtime-2 and Gemini Live API Native Audio both ship this month as production developer APIs with serious capabilities. If you’ve been deferring voice features because the models weren’t good enough, that excuse is gone. The features are there; the product work is yours to do.

The integration layer is where value accumulates. Perplexity, ZoomMate, Copilot — the products that are compounding are doing so not by having better models but by being embedded deeper in existing workflows. If your AI product still requires users to come to it rather than finding them in context, you have a distribution problem as much as a product problem.

None of this is inevitable. The gap between what the models can do and what most shipped products actually expose is still wide. The features above represent the leading edge — the builders who figure out how to bring these capabilities into coherent, trustworthy product experiences will define the next wave.

Have a feature you think should have made this list? The best ones are usually the ones you find in the changelog, not the press release.