Google’s Antigravity Teamwork framework is built for long-running research and engineering jobs, with groups of AI agents proposing, challenging, verifying, and refining each other’s work over hours or days. Google reports seven notable open-problem results from its Long Proof work, while a Gemini 3.7 Flash team separately built a cycle-level out-of-order RISC-V CPU simulator that booted xv6 to a shell and matched hardware timing within 0.71% on average.

Google let the agents keep working — and the jobs got ambitious

Google has been testing Gemini models in teams of autonomous agents, and the latest results are far beyond the usual “build me an app” demo.

With Antigravity Teamwork, groups of agents can work for hours or days on the same objective. They propose approaches, challenge one another’s results, verify intermediate work, and keep iterating until they have something ready for human review.

Google says that setup has now produced seven notable results across open problems in mathematics and theoretical computer science. In a separate systems-engineering test, a Teamwork configuration powered by Gemini 3.7 Flash built a cycle-level out-of-order RISC-V CPU simulator from scratch, booted xv6 to a working shell, and ran more than 100 standard RISC-V benchmarks.

That combination is what makes this update worth watching. Teamwork is being used on proofs, processor simulation, and real open-source performance work — three very different jobs, all built around the same idea: give several agents a shared objective and enough structure to keep improving the result.

Teamwork is more structured than “put several agents on it”

Google first introduced Teamwork as a multi-agent orchestration framework inside Antigravity. The current version is available through the `/teamwork-preview` command, and it does not use one fixed team for every problem.

Instead, Teamwork works with patterns. A pattern defines the roles the agents should play, how their work should move between them, and what has to be checked before the job can advance. Antigravity chooses a pattern based on the task and can change the number of agents while the run is underway.

The current set includes Iterative Coding, Distributed Coding, Long Proof, Self-Verification, and Document Review. A software project that splits cleanly into parallel work can use a different structure from a mathematical proof that needs repeated strategy search and verification.

That separation is important. The useful part is not simply having more model instances running at once. It is giving them a workflow that says who proposes, who checks, who combines, and when another round is worth running.

The seven research results come with an important model detail

The Long Proof pattern is where Google reports the seven notable open-problem results. It generates several candidate strategies, pairs them with agents that try to break or verify them, and then combines the strongest surviving ideas into a more complete approach.

The results span coreset construction for ℓp subspace approximation, sparse convex optimization, maximal inner-product embeddings, Hadamard quantization, the Erdős unit-distance problem, prefix-matrix factorizations, and Knuth’s Cycles Conjecture. Five resulting papers are available on arXiv.

There is one detail worth getting exactly right: Google says the seven results were obtained using Gemini 3.1 Pro. Three of them — problems 1, 3, and 4 in Google’s list — were also reproduced with Gemini 3.7 Flash. So this is not a claim that Flash alone produced all seven results.

For Knuth’s Cycles Conjecture, Google reports first proofs for two simpler constructions of the even-integer case, with proofs running beyond 40 and 70 pages. The shorter proof was formally verified in Lean. For the broader set, Google says human experts reviewed and confirmed the results, with Lean providing the formal verification path for the Knuth work.

Then Gemini 3.7 Flash built a CPU simulator

The hardware result is easier to picture.

Using Gemini 3.7 Flash, Teamwork built a highly accurate cycle-level simulator for an out-of-order RISC-V processor. It was not just executing RISC-V instructions functionally. The goal was to model the timing behavior of a modern out-of-order design closely enough to compare cycle counts against hardware ground truth.

The agents worked through two phases. First came functional correctness: building execution logic for pieces such as reorder buffers, caches, and the out-of-order pipeline, then getting the simulator to maintain correct architectural state and boot xv6. The second phase focused on timing, aligning the simulator’s behavior against strict reference measurements.

Google says the finished simulator booted xv6 all the way to a shell and successfully simulated more than 100 standard RISC-V benchmarks. On unseen test workloads, it reached an average cycle-alignment error of 0.71% against BOOM hardware execution ground truth.

That is a much richer engineering target than generating source code that compiles. The team had to build the simulator, run microbenchmarks, inspect traces, compare timing, and keep refining the microarchitecture until the behavior lined up with the reference.

The same framework also shipped real open-source optimizations

Google also pointed Teamwork at existing open-source software.

For Eigen, the widely used C++ linear-algebra library, the agents worked through microbenchmarks and identified an opportunity around matrix-vector operations where the matrix has a single row or column. The resulting implementation added a dedicated fast path using direct data access, SIMD operations, and four-way accumulator unrolling. Google says the change went through the normal open-source review process and landed upstream with assistance from Gemini 3.6 Flash.

A second project focused on ParlayHash, a high-performance concurrent hash table. Teamwork contributed to the design of “Swiss Parlay,” which brought ideas from Swiss Table into the library.

Google reports 2× throughput on initial inserts with 64 threads, 1.5× overall throughput with a single thread, and memory use per element that was 25% lower than the comparison sequential table while staying close to its performance. The improvement also landed upstream.

These examples give Teamwork a different kind of credibility from a closed benchmark. The work ended up inside existing projects after external maintainers reviewed it through their normal process.

The interesting part is the loop, not the agent count

Multi-agent systems are easy to describe as “several AIs working together,” but Teamwork’s design is more specific than that.

For Long Proof, candidate strategies compete before the system commits deeply to one route. Subproblems can be split into a dependency graph and solved in parallel where possible. Verification is built into the process, and later rounds can reuse useful results and observations from earlier work.

The coding patterns use a different rhythm. Distributed Coding can fan a decomposable engineering job across parallel workers and bring in critic review. Iterative Coding keeps a tighter agent-test-refine loop for work that needs repeated local improvement.

The result is a framework that changes shape around the problem. Mathematics, processor simulation, and library optimization do not need the same team structure, even if all three benefit from longer-running collaboration.

This is already moving into the Antigravity developer workflow

Teamwork is not only a Google research harness. The updated framework is being rolled into Antigravity through `/teamwork-preview` on paid plans, with Google saying more of the improvements will arrive over the next few weeks.

Gemini 3.7 Flash is a natural fit for that environment because Google is positioning it specifically around coding and agents. The model launched in August as Google’s latest Flash workhorse for software engineering, knowledge work, web development, and multi-step agent workflows.

That gives the research results a direct connection to a product developers can actually experiment with. The exact high-parallelism configurations behind some of Google’s research runs are not simply the default consumer setup, but the orchestration ideas are becoming part of the same Antigravity environment.

The broader direction is clear: the unit of work is getting larger. Instead of asking one model for one answer, developers can hand a structured team a problem and let the system keep working through planning, implementation, testing, critique, and verification.

The Upgrade Feeling

The strongest part of this story is not a single benchmark number.

It is the range of work produced by the same orchestration idea. One Teamwork pattern can spend hours exploring a proof. Another can build and calibrate a CPU simulator. Another can optimize production-grade C++ and send the result through an upstream review.

That makes agent orchestration feel less like a demo layer and more like an engineering primitive. The model still matters, but the structure around the model is starting to matter just as much: roles, verification, parallelism, shared state, and the ability to keep working long enough for a difficult problem to unfold.

For developers following the agent space, that is the signal here. The next jump may come from better models — but also from giving those models better ways to work together.

Agent Merge Moves Copilot Into the Final Stretch of a Pull Request

GitHub announced on September 4, 2026 that Agent Merge is now in public preview as part of the VS Code 1.136 release updates. The feature is designed to help get a pull request ready to merge by resolving review feedback, failed checks, and merge conflicts. That is a meaningful expansion of the coding-agent workflow because the work does not stop when code is generated. Copilot is being pushed further into the stage where changes are reviewed, validated, repaired, and prepared for the final merge.

The Goal Is a Merge-Ready Pull Request

The new feature is centered on a simple outcome: take a pull request that still has blockers and help move it toward a state where it can be merged. GitHub’s changelog names three common blockers directly: review feedback, failed checks, and merge conflicts. These are exactly the kinds of issues that often appear after the main implementation is already finished. Agent Merge gives Copilot a role in that follow-through instead of leaving every cleanup step as a separate manual task.

Review Feedback Can Become an Agent Task

GitHub’s Copilot app documentation already shows the broader workflow behind this idea. When a pull request has review comments, a developer can ask an agent to resolve a comment with a Fix action. The agent can inspect the requested change, update the code, and continue the pull request workflow. Agent Merge builds on that direction by making review feedback part of a larger merge-readiness process rather than a disconnected step.

Copilot Can Work on Failing CI Checks

GitHub also documents Copilot workflows for failing CI checks. In the Copilot app, developers can ask an agent to fix failing checks from the pull request view. In Copilot CLI, the /pr fix ci command lets Copilot inspect failing CI jobs, analyze the logs, apply targeted fixes, push the changes, and re-check the CI status. This makes automated validation part of the same agentic loop as code changes.

Merge Conflicts Are Now Part of the Agent Workflow

Merge conflicts are another important part of the new flow. GitHub already lets Copilot cloud agent help resolve conflicts from a pull request. The agent can analyze the conflicting changes, resolve them, and verify that the build, tests, and linter still pass before requesting review. Agent Merge brings that capability into a broader workflow whose goal is to move the entire pull request toward merge-ready status.

Copilot CLI Shows the Full Pull Request Lifecycle

GitHub’s /pr command in Copilot CLI makes the direction especially clear. Developers can view pull request status, create a pull request, address review feedback, resolve merge conflicts, fix CI failures, or run the entire sequence. The /pr fix command handles feedback, conflicts, and CI in order, while /pr auto can continue looping through those phases until the pull request is fully green. Agent Merge fits directly into this larger move toward end-to-end pull request automation.

One Command Can Address the Main Pull Request Blockers

The /pr fix workflow is a useful preview of how GitHub is thinking about agentic pull request work. It runs three phases: review feedback, conflicts, and CI failures. Those are the same categories highlighted in the Agent Merge announcement. Instead of requiring the developer to jump between several tools and manually coordinate each repair, Copilot can work through the sequence as one connected task.

Agent Merge Can Keep Working in the Background

GitHub’s Copilot app documentation describes Agent Merge as a background workflow. When enabled, it prompts the workspace’s Copilot session to read the pull request, fix what is blocking it, and merge it as soon as GitHub allows. The workflow survives app restarts and turns itself off once the pull request is merged. That makes the feature feel less like a one-shot command and more like an ongoing agent watching the state of the pull request until the job is complete.

The Human Still Owns the Final Development Workflow

The strongest version of this workflow is not about removing developers from the process. GitHub’s own documentation keeps review and repository rules in the loop. Copilot can make changes, resolve blockers, and request review, while normal branch protections, approvals, and repository settings continue to determine when a merge is allowed. That keeps the agent focused on execution while the project’s existing collaboration model remains intact.

Copilot Was Already Moving Into Pull Request Repair

GitHub has been expanding Copilot cloud agent beyond code generation for months. In an official GitHub Checkout demonstration, the company showed Copilot working on pull requests, resolving merge conflicts, and handling development tasks around CI and review. Agent Merge turns that broader direction into a more explicit merge-readiness feature inside the current VS Code release cycle.

The Agent Can Read the Pull Request as a Working Context

A pull request contains much more than a diff. It includes review comments, CI status, branch relationships, code changes, and project history. GitHub’s Copilot app lets an agent operate with this pull request context and start a session directly from the PR. That gives the model a richer working surface than a generic code prompt because the agent can act on the state of the actual change that is moving through review.

This Changes What a Coding Agent Is Expected to Finish

Early coding assistants were mainly judged by how well they generated code. Agent Merge points toward a broader definition of completion. A useful coding agent is increasingly expected to help with the full path from implementation to review, validation, conflict resolution, and merge readiness. The result is a workflow where the agent is responsible for more of the delivery process, not just the first draft of the code.

Pull Request Automation Is Becoming More Continuous

The combination of Agent Merge, Copilot CLI pull request commands, cloud-agent conflict resolution, and CI repair shows a clear pattern. GitHub is connecting individual Copilot actions into continuous workflows. A developer can ask for a change, move it into a pull request, respond to feedback, repair checks, resolve conflicts, and continue until the repository’s merge conditions are satisfied. The boundaries between coding, review, and release preparation are becoming much more connected.

VS Code Is Becoming a Home for Agent Sessions

The same VS Code 1.136 update also adds new ways to manage agent sessions. GitHub’s changelog notes multi-root workspace experiments, chat-session organization, and indicators for sessions that need attention. These additions matter because long-running agents need a place where developers can see what is happening, return to a task, and understand which sessions require input. Agent Merge fits naturally into that environment.

The Pull Request Becomes an Active Agent Workspace

With Agent Merge, the pull request is no longer just a review artifact at the end of coding. It becomes an active workspace where an agent can keep contributing after the initial implementation. Review feedback can lead to new edits, CI results can trigger repair work, and merge conflicts can become another step in the same ongoing session. That turns the PR into a live coordination point between the developer, reviewers, repository rules, and Copilot.

GitHub Is Connecting Copilot Across App, CLI, Cloud Agent and VS Code

One of the most important aspects of this update is that the same pull request lifecycle is appearing across several GitHub surfaces. The Copilot app can respond to reviews and failing checks. Copilot CLI exposes /pr commands for the full workflow. Copilot cloud agent can resolve conflicts directly from GitHub. VS Code now adds Agent Merge. The pieces are converging around one idea: Copilot should be able to participate wherever the pull request is being worked on.

The Upgrade Feeling

Agent Merge is a strong example of coding agents moving from code creation into software delivery. GitHub is giving Copilot a larger role after the first implementation is done: read the pull request, respond to review feedback, work through failing checks, resolve merge conflicts, and keep moving toward merge-ready status. For developers, that means the agent is becoming less like an autocomplete layer and more like a collaborator that can stay with a change through the final stages of the pull request.

Muse Spark 1.3 Pushes Meta Deeper Into Agentic Coding

Meta introduced Muse Spark 1.3 on September 2, 2026 as the newest step in its Muse model family. The release is aimed directly at developers building coding agents and AI-assisted development workflows. Meta says the model is trained for long-horizon agentic work, meaning it is designed to keep context across a larger task, remember prior results, and continue through multiple stages instead of treating every turn as an isolated request.

Long-Horizon Work Is the Main Theme

The clearest idea behind Muse Spark 1.3 is continuity. Meta says the model tracks context and prior results while working through messy or conflicting inputs. That matters for software work because real development tasks often span many files, tools and decisions. An agent may need to understand an existing codebase, make a plan, change several components, validate what happened, and then continue from the new state. Muse Spark 1.3 is tuned around that longer execution loop.

The Model Is Tuned for Coding Agents

Meta describes Muse Spark 1.3 as tuned for long-horizon coding workflows with fewer unnecessary turns and cleaner output. The company positions it both for developers building coding agents and for people using AI as a development partner. That makes the model relevant beyond code completion. The target is a system that can participate in a larger engineering task where planning, context retention and tool use matter as much as generating individual snippets.

Muse Spark 1.3 Can Perceive Images, Video and Documents

One of the strongest parts of the release is native multimodal perception. Meta says Muse Spark 1.3 can perceive video, images and documents. A developer can give it a screenshot or a clip and ask it to build from what it sees. That creates a practical connection between visual inputs and software generation, especially for interface work, prototypes and workflows where the source material is not already available as clean text.

Visual Reasoning Runs Through a Real Execution Environment

Meta also says the model’s visual reasoning runs through a real execution environment rather than a scripted sequence. The important point is that perception is connected to action. Muse Spark can interpret a visual input and then use that understanding inside a development workflow. For example, a screenshot can become an input to a coding task rather than something that has to be manually translated into a written specification first.

Muse Code Turns the Model Into a Terminal Workflow

Muse Code is the terminal coding experience built around Muse Spark. Meta says multiple agents can coordinate on every task. Instead of one agent handling every part of a project sequentially, Muse Code can distribute work across several agents and bring their results together. This is a useful model for development because many software tasks naturally break into parallel pieces such as implementation, testing, documentation and review.

Multi-Agent Orchestration Is a Core Part of the Stack

Meta has been building multi-agent orchestration into the Muse family from the beginning. The original Muse Spark release introduced parallel-agent reasoning, and the current developer stack makes that idea practical for coding. Meta’s quickstarts include a four-profile agentic team that can turn a one-line product idea into a working SaaS application. That shows where the company wants the workflow to go: one objective can fan out into coordinated specialist tasks.

Agent Fan-Out Can Work in Parallel

Meta also provides an agent fan-out pattern where multiple subagents can work in isolated worktrees. This lets different agents tackle parts of the same software project without stepping on one another’s changes while they are working. For larger coding systems, that architecture is useful because it turns parallelism into a first-class part of the workflow rather than requiring every task to wait for the previous one to finish.

Computer Use Connects the Agent to Real Interfaces

The Meta developer stack also includes a computer-use path for Muse Spark. Meta describes this as giving the model eyes and hands so it can build software the way a person does. For developers, that means an agent can potentially move beyond code generation and interact with interfaces involved in the development process. Combined with multimodal perception, this gives Muse Spark a broader working surface than a text-only coding assistant.

A GitHub Agent Is One of Meta’s Reference Workflows

Meta includes a GitHub agent among its official quickstarts, using Muse Spark with OpenCode on the Meta Model API. This is a good example of the model being positioned as infrastructure for autonomous developer tools. GitHub is where code, issues, pull requests and project history come together, so an agent operating there can participate in a workflow that is much closer to real software engineering than a standalone chat window.

Muse Code Covers Game, Web and Multimodal Development

Meta highlights game development, web development and multimodal visual coding as Muse Code examples. These categories show how broad the intended use is. The same model can work on a conventional software project, use visual material as part of the build process, or support interactive experiences. That range is important because long-horizon agents become more useful when they can move between code, visuals and application behavior without changing systems.

The Meta Model API Makes Muse Spark Available to Builders

Muse Spark is also available through the Meta Model API, giving developers a direct way to put the model inside their own products and workflows. Meta says developers can point an OpenAI SDK-compatible client at the Meta Model API for a quick start. That lowers the amount of plumbing needed to test the model in an existing agent stack, especially for teams already using OpenAI-compatible interfaces in their tooling.

Public Preview Expands Access to the Developer Stack

Meta currently presents Muse Spark on Muse Code and the Meta Model API as a public preview with expanded global access. That makes the release more than a research showcase. Developers can start experimenting with the model, terminal agent experience and API workflows now. The combination gives Meta both a model layer and a developer-facing execution layer, which is becoming an important pattern across modern AI coding products.

Muse Spark Started as a Native Multimodal Reasoning Model

The broader Muse Spark family was introduced in April 2026 as Meta’s first model family from Meta Superintelligence Labs. From the start, Meta described Muse Spark as natively multimodal with tool use, visual reasoning and multi-agent orchestration. Muse Spark 1.3 builds on that foundation with a more explicit emphasis on coding and long-horizon agentic workflows. The progression shows the model family moving from general multimodal reasoning toward more concrete developer execution.

Coding and Multimodality Are Converging

One of the most interesting patterns in Muse Spark 1.3 is the way coding and multimodal perception are being combined. A developer agent no longer has to receive every requirement as text. It can inspect a screenshot, video or document, understand what it contains, and use that information while building. That opens the door to workflows where design references, product demos, diagrams and existing interfaces become direct inputs to software creation.

The Agent Is Becoming the Workflow, Not Just the Assistant

Traditional coding assistants sit beside the developer and respond when asked. Muse Spark 1.3 is aimed at something broader: an agent that can keep working across a longer objective, coordinate with other agents, use a computer, inspect visual material and interact with developer systems. The change is not only about model intelligence. It is about giving the model a larger execution loop and more places where it can act.

Meta Is Building a Full Developer Surface Around Muse

Meta is pairing Muse Spark with Muse Code, the Meta Model API, quickstarts for multi-agent orchestration, agent fan-out, computer use and GitHub automation. Taken together, these pieces form a developer surface rather than a single model endpoint. That is important because the practical value of an agent often depends on the environment around it: the tools it can call, the context it can retain, and the workflows it can participate in.

The Upgrade Feeling

Muse Spark 1.3 is a strong example of where AI coding is heading next. Meta is not limiting the model to text generation or short code suggestions. It is building around long-horizon execution, multimodal perception, multiple cooperating agents and direct integration with developer tools. For builders, the most interesting part is the combination: one model that can see visual inputs, keep track of a longer job, coordinate work and operate through a developer-focused stack.

Claude Fable 5.1 Is Designed for Work That Keeps Going

Anthropic introduced Claude Fable 5.1 on September 1, 2026 as its most capable generally available model for coding and knowledge work. The most important shift is not simply a new model number. Anthropic is positioning Fable 5.1 for work that can continue for hours, move between applications, use tools, recover from failed steps, and keep progressing without constant supervision. That makes the release especially relevant to developers and teams building agentic workflows rather than using AI only for one prompt at a time.

The Model Is Built for Hours-Long Agent Jobs

Anthropic describes Fable 5.1 as a model for ambitious, long-running projects. In its agent examples, the company points to working through a backlog in Claude Cowork, picking up requests from Slack through Claude Tag, operating a browser, and running unattended as a managed agent on the Claude Platform. The common idea is continuity. Instead of completing one isolated answer, the model can plan a larger job, select tools, move through stages, and keep working until the task is ready for review.

Planning and Recovery Are Part of the Workflow

A long-running agent needs more than strong text generation. Anthropic says Fable 5.1 can plan the work, use the tools it needs, recover when a step fails, and keep the user updated as it goes. That combination matters because real projects rarely follow a perfect straight line. A coding task may require reading documentation, changing files, running tests, revisiting an earlier assumption, and checking the final result. Fable 5.1 is being presented as a model designed to stay coherent across that whole sequence.

Claude Cowork Gives the Model a Broader Work Surface

Anthropic specifically highlights Claude Cowork as one place where Fable 5.1 can take on extended work. Cowork is designed around delegating larger projects rather than treating every interaction as a short chat. With Fable 5.1, that model of work becomes more ambitious: a user can hand over a backlog or multi-stage assignment and review the result after the model has worked through the steps. The practical change is that Claude is moving closer to a project worker that can carry context across a longer job.

Claude Tag Extends That Agent Model Into Slack

Claude Tag adds another surface. Anthropic launched Claude Tag in Slack so teams can bring Claude into selected channels, connect it to tools and data, and delegate tasks by tagging @Claude. The company says Claude can break work into stages, operate asynchronously, and return with what it created. Fable 5.1 is now explicitly positioned for this kind of cross-application work, which connects model capability with a place where teams already coordinate projects.

Browser Work Makes the Agent More General

Anthropic also lists browser operation as a Fable 5.1 use case. That matters because many real tasks are not contained inside one code editor or one document. Research, dashboards, internal tools, forms, web applications, and cloud services often live in a browser. A model that can keep a plan while moving through browser-based steps can cover a much wider range of workflows than a model limited to generating text or code in isolation.

Managed Agents Bring the Same Idea to the Claude Platform

For developers building their own products and internal systems, Anthropic points to managed agents on the Claude Platform. The idea is to let a long-running Claude process execute programmatically rather than only through Claude’s consumer interfaces. This gives teams a way to build workflows where the model can receive a larger objective, use connected tools, and continue working in the background of an application until it has completed the job.

Coding Is One of Fable 5.1’s Main Targets

Anthropic calls Fable 5.1 its most capable model for ambitious coding projects. The company highlights features that span an entire codebase, code review, performance work, and multi-day autonomous sessions. These are very different from small code-completion tasks. They require the model to understand relationships between files, keep track of design choices, make coordinated edits, and verify that the system still works after those edits.

The Model Can Write Tests to Check Its Own Work

One of the more practical details in Anthropic’s description is that Fable 5.1 can write its own tests to verify its work. That gives the agent a feedback loop. Instead of only generating a change and stopping, it can create a test, run it, inspect the result, and continue adjusting the implementation. For developers, that is a more useful pattern than treating the model as a code generator because it brings verification into the same workflow.

Vision Is Used as Part of Coding Verification

Fable 5.1 also uses vision to check outputs against a design or goal. Anthropic says the model can implement designs with high fidelity and use visual understanding to evaluate what it produced. That creates an interesting bridge between coding and interface work. A model can change the code, render the result, visually inspect the output, and compare it with the intended design rather than relying only on source code and test output.

Document-Heavy Work Is Another Major Use Case

The model is not limited to software engineering. Anthropic says Fable 5.1 can understand diagrams, charts, and tables nested inside files and PDFs. That broadens the model’s usefulness for long-form research, analysis, and document-heavy projects. A complex assignment can combine prose, structured information, visual material, and multiple files while remaining inside the same working context.

Enterprise Workflows Move Toward Delegation

Anthropic describes Fable 5.1 as capable of handling complex, multi-stage knowledge work with minimal oversight. The intended workflow is clear: teams can hand over a large project, allow Claude to work through the steps, and then review a finished deliverable. That is a different relationship from supervising every prompt. The model is being designed around delegation, where the human sets the objective and the AI handles more of the execution path.

The Cost Change Is Especially Important for Agents

Long-running agents can reuse the same context many times. That makes prompt caching important because the agent may repeatedly reference a large codebase, instructions, documents, or project state. Anthropic cut Fable 5.1 cache-read pricing to $0.25 per million tokens, which the company says is 75% lower than Fable 5. This directly targets the economics of workflows that keep the same context active while performing many steps.

Anthropic Estimates About 25% Lower Cost for Typical Workloads

According to Anthropic, the cheaper cache reads reduce the cost of typical Fable 5.1 workloads by an estimated 25%. The base model price remains $10 per million input tokens and $50 per million output tokens, so the major efficiency change comes from how much cheaper it is to read previously cached context. For workflows that repeatedly reuse large prompts or project state, that can change the total cost of a long session more than a simple headline token price suggests.

Highly Agentic Workloads Can See a Bigger Difference

Anthropic says highly agentic workloads can cost up to approximately 45% less because of the new cache-read pricing. That is the number that makes this release especially interesting for developers building agents. The more a workflow plans, calls tools, revisits context, and continues through multiple stages, the more valuable inexpensive cache reads can become. The release therefore pairs stronger long-running behavior with a pricing change aimed at the exact workloads that use it most.

The API Model ID Is Ready for Developers

Fable 5.1 is available through the Claude API using the model ID claude-fable-5-1. Anthropic also lists availability through its platform marketplaces and across Amazon Web Services, Google Cloud, and Microsoft Foundry. That means the model is not only a Claude.ai feature. Developers can bring the same model into applications, coding systems, internal tools, and agent architectures built around the Claude Platform.

Availability Covers Claude’s Main Paid Workflows

For individuals and organizations, Anthropic says Fable 5.1 is available to Pro, Max, Team, and Enterprise users. The model is also positioned across Claude Code and Cowork workflows. This broad availability matters because Anthropic is not presenting Fable 5.1 as a research preview. It is meant to be used now for production-oriented coding and knowledge work where longer execution and stronger tool use are valuable.

The Bigger Shift Is From Chat Sessions to Ongoing Work

The most interesting part of Fable 5.1 is the shape of the product around it. Claude can now appear in a coding environment, a collaborative workspace, Slack, a browser, or a managed-agent workflow. Across those surfaces, the model is being asked to preserve a plan and continue working rather than waiting for a new prompt after every step. That moves AI interaction away from a sequence of isolated conversations and toward ongoing execution.

The Upgrade Feeling

Claude Fable 5.1 looks like an important step in Anthropic’s push toward AI that can own more of a project from start to finish. The model is built for hours-long work, codebase-wide changes, browser tasks, team workflows, and managed agents. At the same time, Anthropic has made repeated access to cached context much cheaper, with estimated savings of around 25% for typical workloads and up to roughly 45% for highly agentic ones. The combination is what makes this release stand out: stronger long-running execution paired with a cost structure designed for agents that keep working.

NVIDIA Is Bringing the Open Model Hub Into Its AI Platform

NVIDIA announced on September 3, 2026 that it has agreed to acquire Hugging Face. The announcement immediately connects two very different but highly complementary parts of modern AI development. NVIDIA builds the accelerated computing platforms used across training, inference, graphics, robotics, and large-scale AI infrastructure. Hugging Face has become a central place where developers discover models, datasets, applications, libraries, and deployment options. NVIDIA’s stated goal is to scale the Hugging Face platform, strengthen its infrastructure, and expand access to AI for developers and institutions around the world.

Hugging Face Has Become One of AI’s Main Discovery Layers

The scale NVIDIA highlighted helps explain why this deal matters to developers. According to NVIDIA’s announcement, more than 18 million developers, researchers, and creators use Hugging Face. The platform hosts more than 3 million models, around 500,000 datasets, and about 1 million applications, while more than 200,000 companies use the platform to discover, evaluate, customize, and deploy AI. Those numbers make Hugging Face more than a repository. It acts as a discovery layer across the open-model ecosystem, connecting model creators, application builders, inference providers, researchers, and organizations in one shared environment.

The Most Important Promise Is That the Hub Stays Open

NVIDIA’s announcement makes openness a central part of the acquisition. The company says Hugging Face will remain an open platform for the entire AI ecosystem. Developers will continue choosing the models they want, the frameworks they want, the cloud platforms they want, the inference service providers they want, and the computing platforms they want. NVIDIA goes one step further and says NVIDIA compute will not be required to build on or deploy through Hugging Face. That statement preserves one of the Hub’s defining characteristics: it is designed to connect many models, tools, and providers rather than force every workflow into one stack.

Model Choice Remains at the Center of the Experience

Hugging Face’s own documentation describes the Hub as a reference platform for open machine learning and as a collaboration layer for models, datasets, and applications. Model repositories can contain weights, configuration files, documentation, evaluation information, and version history. Developers can browse, compare, download, fine-tune, and integrate models using a wide range of libraries. NVIDIA’s commitment to preserve model choice means this workflow is expected to remain broad. A developer can continue selecting the model that fits the task rather than treating the platform as a catalog tied to one model family.

Framework Choice Is Part of the Same Open Design

Modern AI development rarely uses one framework for every job. Teams move between Transformers, PyTorch-based workflows, optimized inference runtimes, local engines, orchestration tools, and custom application code. NVIDIA explicitly says developers will continue choosing their preferred frameworks on Hugging Face. That is important because the Hub has grown partly by serving as a common meeting point between many software ecosystems. A model can live in one repository while being discovered, tested, downloaded, or deployed through different tools. Keeping that flexibility gives the combined platform room to support many different development styles.

Cloud Choice Also Remains Flexible

NVIDIA’s statement also preserves cloud choice. Hugging Face already supports dedicated endpoints and deployment workflows across different infrastructure environments, and its documentation describes the Hub as a collaboration layer rather than a single-cloud destination. That flexibility matters because AI teams often choose deployment environments based on workload, geography, scale, organizational requirements, or existing architecture. NVIDIA’s announcement says those choices will remain available after the acquisition, keeping the Hub positioned as a common layer that can connect models to multiple infrastructure paths.

Inference Provider Choice Is Especially Important

Hugging Face’s Inference Providers system already gives developers one interface for running models through a broad set of serverless inference partners. Its current documentation lists providers including Cerebras, Cohere, DeepInfra, fal, Fireworks, Groq, Replicate, Scaleway, Together, and others alongside Hugging Face’s own inference services. Developers can use the Hugging Face SDK with a selected provider or let the client route automatically. NVIDIA’s promise that inference-provider choice will continue is therefore directly connected to a major part of the Hub’s current design.

The Hub Is More Than a Model Download Page

Hugging Face repositories are Git-based and support versioning, commit history, diffs, branches, collaboration, and integrations. The platform also hosts datasets and Spaces, giving developers a way to move from a model file to evaluation data, demonstrations, applications, and interactive experiments without leaving the same ecosystem. That broader structure is one reason the acquisition reaches beyond model hosting. NVIDIA is not only gaining a catalog of weights. It is bringing a large developer workflow, collaboration surface, and model-discovery network closer to its own AI software and infrastructure ecosystem.

Datasets Are a Major Part of the Platform

Datasets are another important layer. Hugging Face’s documentation describes datasets on the Hub as repositories that can include training, evaluation, and testing data together with Dataset Cards and browser-based viewers. Developers can search by task, language, license, and other attributes, then access datasets through the Hub or programmatically through the datasets library. NVIDIA’s acquisition therefore connects compute not only to finished models, but also to the data workflows used to evaluate, adapt, and build AI systems. That gives the combined ecosystem a wider development surface from experimentation through deployment.

Spaces Turn Models Into Working Applications

Hugging Face Spaces add an application layer on top of the Hub. Developers can build interactive demos with Gradio, Docker, or static HTML, link models and datasets, and publish working AI experiences that other users can test directly in the browser. This turns model discovery into something more tangible. Instead of only reading a model card, a user can often interact with an application built around the model. In the context of NVIDIA’s acquisition, Spaces give the platform a visible application layer that sits between model repositories and full production deployment.

NVIDIA Already Works With Hugging Face Models Today

The two ecosystems are already connected technically. NVIDIA’s NIM documentation includes Hugging Face as a model source, using Hugging Face repository identifiers and tokens when needed. NVIDIA NeMo Platform documentation also describes workflows for deploying supported Hugging Face models. That means the acquisition is not starting from zero integration. Developers already move models between Hugging Face repositories and NVIDIA deployment tooling. Bringing the organizations together can make those paths easier to coordinate while the Hub continues supporting other infrastructure options.

The Combination Connects Discovery With Accelerated Deployment

One of the clearest opportunities is the connection between discovering a model and running it efficiently. Hugging Face is where many developers begin: search for a model, inspect the model card, compare alternatives, test an application, download weights, or call an inference provider. NVIDIA’s software stack begins to matter when teams want accelerated training, optimized inference, or larger-scale deployment. Bringing those layers closer creates a more continuous path from finding a model to experimenting with it and then moving into optimized production infrastructure when that is the right fit.

Open Models Can Reach More Production Paths

Hugging Face’s current inference architecture already supports several routes: hosted inference providers, managed endpoints, and local endpoints such as llama.cpp, Ollama, vLLM, LiteLLM, and Text Generation Inference. NVIDIA’s announcement says those kinds of choices will remain open. That means the Hub can continue serving as a model layer that feeds many production paths. NVIDIA can add stronger integrations and infrastructure around its own stack without removing the broader routing model that developers already use.

The Developer Experience Is the Real Center of the Deal

The announcement is easy to describe as a connection between a hardware company and a model platform, but the developer workflow is the more useful lens. Hugging Face sits where developers search, compare, evaluate, share, and collaborate. NVIDIA sits where many teams optimize and scale AI workloads. The value of the combination comes from reducing the distance between those activities. A developer can begin with an open model, evaluate it, test it in an application, choose an inference path, and move toward deployment while staying inside a connected ecosystem.

Hugging Face Keeps Its Role as a Multi-Provider Layer

The most distinctive part of NVIDIA’s announcement is that Hugging Face is expected to continue supporting many providers rather than becoming an NVIDIA-only front end. Developers can keep choosing cloud platforms, inference services, frameworks, and compute. That preserves the Hub’s usefulness as neutral connective tissue across AI workflows. NVIDIA can still improve integration with its own software and infrastructure, but the platform can remain valuable to developers who use different hardware or deployment environments.

NVIDIA Gets Closer to Where Model Decisions Begin

Most infrastructure decisions happen after a team has already chosen or narrowed down a model. Hugging Face sits much earlier in that process. Developers use the Hub to discover what exists, inspect how a model was built, compare versions, read documentation, test demos, and identify compatible deployment options. By acquiring Hugging Face, NVIDIA moves closer to that starting point. It gains a direct connection to the layer where millions of developers begin deciding what models and tools they want to use.

Hugging Face Gets a Larger Infrastructure Partner

NVIDIA’s stated plan is to scale Hugging Face’s platform and strengthen its infrastructure. For a service hosting millions of AI artifacts and serving developers around the world, infrastructure is a central part of the product experience. Faster access, stronger deployment paths, larger-scale services, and deeper optimization can all make the Hub more useful as model sizes and application demands grow. NVIDIA’s accelerated computing experience gives the combined organization a substantial technical foundation for expanding those capabilities.

The Open Model Ecosystem Becomes More Connected

AI development is increasingly distributed across model creators, dataset builders, application developers, cloud platforms, inference services, local runtimes, and hardware vendors. Hugging Face already connects many of those pieces. NVIDIA adds another large layer of infrastructure and software to that network. If the company follows the open-platform commitments in its announcement, the result can be a more connected ecosystem where developers keep choosing their tools while gaining more direct paths into accelerated infrastructure when they need it.

This Is a Platform Story More Than a Hardware Story

NVIDIA is best known for accelerated computing, but this acquisition is fundamentally about software distribution and developer access. Hugging Face is one of the places where open models become discoverable, testable, shareable, and deployable. That makes the deal important even for developers who are not thinking about GPUs at the moment they open the Hub. The strategic connection is between the place where AI assets are organized and the infrastructure that can help run them at scale.

The Upgrade Feeling

The biggest idea here is not that NVIDIA now owns another AI company. It is that the company is moving closer to one of the main places where developers discover and use open models. Hugging Face brings the models, datasets, apps, repositories, collaboration tools, and provider connections. NVIDIA brings accelerated infrastructure and a large software stack built around AI deployment. The most encouraging part of the announcement is the promise that the Hub will remain open and multi-provider. If that stays true in practice, developers gain a tighter bridge between open-model discovery and production-scale AI without giving up the choices that made Hugging Face useful in the first place.

Lenovo Used IFA 2026 to Push Qira Into a Much Bigger Role

Lenovo’s IFA 2026 update for Lenovo & Motorola Qira is about expanding where the same personal AI can show up. At Lenovo Innovation World in Berlin on September 3, Lenovo announced that Qira is reaching more eligible PCs, more Motorola devices, a wearable, and a wider set of connected app experiences. The direction is clear: Lenovo wants one intelligence to follow the user across the devices and services that already make up a normal day. That turns Qira from a feature attached to one machine into a broader personal layer that can stay useful while the user moves between screens, applications, and moments.

The Core Idea Is One Personal AI Across Multiple Devices

Lenovo describes Qira as personal ambient intelligence built to work across compatible Lenovo and Motorola devices. The same intelligence appears as Lenovo Qira on Lenovo products and Motorola Qira on Motorola products, with a shared experience designed to carry context across PCs, smartphones, tablets, and wearables. That continuity is the foundation of the whole system. A conversation, saved document, meeting context, or personal knowledge item can remain useful as the user moves between supported devices. The value is not only having AI on several products. It is having one personal AI identity that is designed to remain consistent across them.

IFA Expands Qira to More 16GB Lenovo PCs

One of the most practical IFA announcements is broader PC eligibility. Lenovo says Qira support is expanding to eligible Lenovo PCs with 16GB of memory, extending access beyond the higher-memory configurations that defined earlier availability. That matters because it brings the personal-AI layer into a larger part of Lenovo’s PC portfolio. More compatible systems can now participate in the same cross-device experience, giving Qira a broader hardware base. For users, the important idea is continuity: the same personal knowledge and context can become available on more of the devices they already use.

Motorola Qira Is Expanding With Android 17

Lenovo also says Motorola Qira will expand to eligible Motorola devices as they receive Android 17. The company names select edge, signature, and razr devices in the rollout. This connects the phone more tightly to the same personal-AI identity used on compatible PCs and other Lenovo devices. A phone is a natural place for context because it is with the user throughout the day, capturing conversations, messages, schedules, photos, and quick requests. Bringing Qira deeper into Motorola’s Android lineup gives Lenovo another important surface for keeping the personal experience continuous.

Moto Watch Ultra Becomes Qira’s First Wearable

Lenovo identifies the new moto watch ultra as the first wearable to support Motorola Qira. That is a meaningful expansion because a wearable gives personal AI a different kind of presence. It is closer to the user throughout the day and can become another surface for timely information, quick interactions, and connected experiences. In Lenovo’s broader vision, Qira is not tied to one screen size or one category. The intelligence is the common layer. Moving from PC to phone to wearable makes that idea easier to understand: the device changes, but the personal AI remains part of the same system.

The Bigger IFA Upgrade Is Moving From Devices Into Apps

Lenovo’s new announcement becomes especially interesting when Qira moves beyond hardware and into everyday applications and services. Lenovo says supported Qira experiences can connect with Gmail, Google Calendar, Google Contacts, Slack, Outlook Mail, and Outlook Calendar through its collaboration with Workato. That gives Qira a path from understanding the user’s request to working with information and actions inside the services that already organize email, meetings, contacts, and collaboration. The personal AI can therefore become useful not only because it knows the user’s context, but because it can connect that context to the tools that help complete the next step.

Workato Is the Connectivity Layer Behind the New App Experiences

Lenovo’s separate Workato announcement explains the architecture more clearly. Workato is serving as the connectivity layer powering the underlying Model Context Protocol server infrastructure used for these connected Qira experiences. That detail shows how Lenovo is turning the personal-AI idea into an integration system. Qira can remain the user-facing intelligence while a dedicated connectivity layer helps it reach supported applications and workflows. This separation gives the system a clean structure: personal context and natural-language interaction at the Qira layer, with approved app connectivity underneath.

MCP Gives Qira a Standard Way to Reach More Tools

Model Context Protocol gives AI systems a structured way to connect with tools and data. In Lenovo’s implementation, the Workato-powered MCP layer helps Qira connect natural-language intent with supported services. This creates a useful division of roles. Qira handles the personal context, conversation, and understanding of what the user wants to accomplish. The integration layer exposes approved application capabilities that can help carry out the request. That architecture also gives Lenovo room to expand the ecosystem over time, because new tools can be connected through the same underlying pattern rather than requiring a completely separate personal-AI experience.

The Integration List Extends Beyond Email and Calendars

Lenovo’s Workato release names Microsoft 365, Google Workspace, Trello, Asana, and Discord among the initial integrations described for the collaboration. The Qira expansion release also calls out Gmail, Google Calendar, Google Contacts, Slack, Outlook Mail, and Outlook Calendar. Together, those examples show the range Lenovo is targeting: communication, planning, project management, collaboration, contacts, and personal organization. The point is not the number of logos. The important change is that one personal AI can begin to understand a goal and then connect with different supported services that each handle part of the user’s day.

A Natural-Language Request Can Become an App Action

Lenovo gives concrete examples of how this connected model is meant to work. A user can ask Qira to create a Trello task for a website redesign project, or ask it to share meeting notes with a team in Discord. The value is the direct path between the request and the supported action. The user stays in the Qira experience while the integration layer connects that intent to the service that can complete the next step. This is where personal AI starts to feel more agentic: understanding a request is only the beginning, while completing a useful action across a connected service becomes part of the experience.

Catch Me Up Becomes More Useful When Apps Are Connected

Lenovo specifically highlights Catch Me Up as part of the new connected experience. If an important update arrives through email, a group conversation, or a calendar change, Qira can bring relevant information together and help the user continue from the same interface. That fits the larger ambient-intelligence idea: useful context can follow the user rather than remaining limited to the application where it first appeared. A personal AI becomes more valuable when it can connect information from the places the user already works and communicate what matters in a way that fits the current moment.

The Official Demo Shows Presence, Action and Perception

Lenovo’s official Qira demo describes the system around three ideas: Presence, Action, and Perception. Presence means the same intelligence can remain available across devices. Action is about orchestrating supported tasks across apps and devices. Perception is the ability to build useful knowledge around the user and the context they choose to share. The IFA expansion strengthens all three ideas by adding more device surfaces and a broader application layer. The demo also shows features such as context-aware suggestions, live transcription, a personal knowledge base, cross-device control, local AI, Live Mode, and Catch Me Up.

Qira Can Build a Personal Knowledge Base

Lenovo’s product page emphasizes a personal knowledge base where users can add documents and saved memories that Qira can use to support later interactions. This gives the system continuity that goes beyond a single chat session. A file saved earlier, a remembered preference, or information collected on another supported device can become part of the context available when the user asks for help later. Personal AI becomes more useful when it can build on previous information with the user’s control, because the system can support a continuing workflow rather than treating every request as an isolated moment.

Local AI Keeps Part of the Experience Close to the Device

Qira is also designed to use local AI capabilities on compatible devices. Lenovo’s official materials describe experiences that can work directly on the PC, including offline interactions and local creative features. That local layer complements the connected app ecosystem. Some work can remain close to the device, while connected services can contribute when the task benefits from information or actions available elsewhere. This hybrid model fits Lenovo’s broader AI direction: local hardware, personal context, and connected services can work together as parts of one experience rather than separate products.

User Permission and Control Stay Central to the Design

Lenovo repeatedly frames Qira around user permission, choice, and control. Its IFA announcement says the connected experiences are designed to maintain user permission and control as Qira works across supported services. The Qira product page also describes personal data as being stored on the device and cloud connections being used when needed. That makes control part of the product architecture. For a personal AI that is designed to remember context and connect across multiple services, keeping the user at the center is essential to the experience Lenovo is building.

Lenovo Is Building Toward a Qira Marketplace

The Workato collaboration is described as the first phase of a multi-stage agreement. Lenovo says the work begins with Qira for consumers and is intended to extend toward a broader Lenovo Qira marketplace. That points to a platform strategy rather than a fixed set of integrations. If the ecosystem keeps growing, Qira can become a common personal-AI layer connected to a wider range of services while preserving the same device-to-device identity. The marketplace idea also gives developers and service providers a clearer place in Lenovo’s long-term vision for connected personal AI.

IFA 2026 Makes Qira Feel More Like an Ecosystem Than an App

Qira started the year as Lenovo’s cross-device personal ambient intelligence, and the IFA update makes that concept much more concrete. More PC configurations can participate. More Motorola devices are joining. A wearable becomes part of the system. Workato-powered app connections give the intelligence a way to reach the tools people already use. The result looks less like one application and more like an ecosystem layer that spans hardware, software, and services. That is the bigger story behind the IFA announcement: Lenovo is turning Qira into connective tissue across its personal-computing world.

The Upgrade Feeling

The most compelling part of Lenovo Qira is not a single AI trick. It is the idea that the same personal intelligence can move with the user, carry context across devices, and connect that context to supported actions inside everyday applications. IFA 2026 expands that vision in exactly the places that matter: more devices, more surfaces, and more services. If Lenovo keeps building on this architecture, the upgrade may feel less like opening another assistant and more like having one intelligence already present across the digital environment you use every day.

AMD Put Personal AI at the Center of IFA 2026

AMD used the opening keynote at IFA Berlin 2026 to describe a future in which AI becomes a much more personal part of everyday computing. Jack Huynh, senior vice president and general manager of AMD’s Computing and Graphics Group, presented the idea as a shift in the relationship between people and their devices. Instead of treating AI as a separate destination, AMD’s vision places intelligence directly into the computing experience, close to the user and ready to support the work, ideas, and creative moments already happening on the device.

The PC Is Moving From Tool to Partner

The strongest idea in AMD’s keynote is simple: the PC can become something that works alongside the person using it. IFA described this as computing evolving from a tool we use into an extension of human potential. That changes the role of the machine. A traditional computer waits for a command, opens an application, and carries out a task. AMD’s Personal AI vision adds a new layer where the system can understand what the user is trying to achieve and help move that intention toward a useful result.

Context Becomes Part of the Interface

Personal AI becomes more interesting when the system understands context. IFA’s official keynote description says the next generation of agentic PCs can understand what the user is doing, what they want to achieve, and what matters in that moment. That creates a more natural way to interact with technology because the system is no longer limited to one isolated command at a time. The computer can begin to connect the current task, the user’s goal, and the tools available on the device into a more continuous experience.

Agentic PCs Are Designed to Work Proactively

AMD’s vision also moves beyond AI that only responds when someone asks a question. The keynote focused on more proactive computing, where an intelligent system can work alongside the user and help advance a task. That is the basic promise behind the agentic PC: a machine that can participate in a workflow instead of acting only as a passive endpoint. For creators, developers, and everyday users, this points toward computers that can help organize steps, coordinate tools, and keep progress moving with less friction.

On-Device Intelligence Makes AI Feel More Personal

The IFA program puts on-device intelligence at the center of the Personal AI idea. When more intelligence lives on the device, the experience can stay closer to the person using it and respond directly to the local context of the task. IFA specifically highlighted user control and privacy as benefits of this model. For TUF, the bigger story is the change in interaction: local intelligence gives the PC a chance to become a persistent part of the user’s workflow rather than a separate service that always feels one step removed from the machine itself.

Local Compute Gives the PC a Bigger Role

AMD has been steadily expanding the amount of AI work that can happen on end-user devices, and the IFA keynote connects that hardware direction to a broader experience. Local compute is not only about raw performance. It is what gives Personal AI room to become responsive, available, and closely connected to the applications already running on the system. As CPUs, GPUs, NPUs, memory, and software continue to improve together, the PC becomes a much more capable home for AI-assisted work, creation, and experimentation.

AI-Powered Devices Become Part of the Workflow

AMD’s event page describes the keynote as a look at what becomes possible through AMD AI-powered devices. That phrase matters because it places AI inside the device experience rather than around it. A personal system can become the place where ideas begin, where local models assist with work, where creative tools gain new intelligence, and where agents can coordinate steps across applications. The result is a computing model in which AI is not a single feature. It becomes part of the way the whole device supports the user.

Creativity Is a Core Part of AMD’s Vision

AMD and IFA both framed Personal AI around imagination and creativity, not only productivity. The keynote description points to artists, creators, and innovators as people who can gain new ways to turn ideas into something real. That is a strong direction for the next generation of personal computing. A context-aware system can help move from an early idea to research, drafting, visual exploration, code, media, or other creative outputs while keeping the person in control of the direction.

Personal AI Can Help Turn Intention Into Action

One of the clearest phrases in IFA’s description is the idea of turning imagination into action. That captures what makes agentic computing different from a normal assistant. The system does not only provide an answer; it can help move toward an outcome. A user might begin with a goal, and the PC can help translate that goal into a sequence of useful steps. As more applications expose AI-ready workflows, that connection between intention and execution could become one of the defining experiences of a Personal AI computer.

The Workplace Becomes More Collaborative

IFA’s post-keynote coverage also highlighted the workplace. The event described AI as a way to reduce repetitive work and make collaboration across different parts of a business easier. In AMD’s Personal AI model, the computer becomes an active participant in that environment. It can help prepare information, support creative work, coordinate tasks, and keep useful context close to the employee. That makes the PC more than a collection of applications. It becomes a workspace where intelligence can connect those applications around the person’s actual objective.

Open Infrastructure Expands the Possibilities

Another important part of AMD’s direction is openness. IFA’s official profile for Jack Huynh describes his Personal AI vision as a combination of powerful local compute, open software ecosystems, and intelligent cloud services. Open ecosystems give developers more ways to build, experiment, and connect new experiences across hardware and software. For users, that can translate into a wider range of tools and workflows. For developers, it creates more room to build Personal AI experiences that fit different devices, applications, and ways of working.

Consistent Software Helps Ideas Move Across Systems

IFA’s keynote recap emphasized open infrastructures and consistent software as foundations for developing and deploying AI applications across an organization. That gives AMD’s vision another useful dimension. Personal AI can begin on a local device, but the software around it can help the same ideas travel into larger workflows when needed. A developer can experiment close to the user, refine the experience, and connect it to broader systems. That continuity is especially valuable as AI becomes part of more everyday applications rather than remaining inside isolated demos.

Local and Cloud Intelligence Can Work Together

AMD’s Personal AI direction is not limited to one location for compute. IFA describes a model that brings together local compute and intelligent cloud services. That creates a flexible architecture in which the personal device can handle experiences that benefit from being close to the user while larger services can contribute additional capability when a workflow calls for it. The exciting part is the continuity between the two. The user can remain at the center while the computing environment chooses the resources that best support the experience.

The Hardware Stack Matters More in the Personal AI Era

A Personal AI PC depends on more than a single accelerator. Jack Huynh’s role at AMD spans the company’s PC and graphics businesses, and AMD describes its end-user strategy around leadership CPU, GPU, and NPU technologies. That broader stack is important because modern AI experiences combine many kinds of work: general computing, graphics, model inference, media processing, and application logic. Bringing those capabilities together gives device makers and software developers a richer foundation for building AI experiences that feel integrated with the rest of the PC.

The User Becomes the Center of the System

The phrase Personal AI only works if the technology genuinely revolves around the person. That is why context, adaptation, local intelligence, and user control appear repeatedly in the IFA description of AMD’s keynote. The system is valuable because it understands the current goal and helps the user move forward. This is a different design philosophy from adding an AI button to an existing application. It suggests that the entire computing environment can become more responsive to the person, the task, and the moment.

IFA 2026 Made the Direction Clear

IFA gave AMD a large stage for this message. The opening keynote took place on September 4, 2026, on the Innovation Stage in Berlin, with Personal AI presented as one of the defining themes of the next computing era. That positioning matters because it connects AMD’s hardware work to a clear experience goal. The company is not only talking about faster AI processing. It is describing what that processing is meant to enable: more personal, proactive, context-aware computing that works alongside people.

Personal AI Is Becoming a Platform Idea

The most important takeaway from AMD’s keynote is that Personal AI is bigger than one feature or one model. It is a platform idea built around local hardware, software, applications, agents, and cloud services working together. When those layers are designed around the user, the PC can become a place where intelligence is always available as part of the workflow. That creates room for entirely new categories of software, from context-aware creative tools to personal agents that can coordinate work across multiple applications.

What This Means for the Next Generation of PCs

The next generation of PCs can be judged by more than processor speed, display quality, or battery life. Personal AI adds another question: how well does the system understand and support what the user is trying to do? AMD’s IFA vision points toward devices where AI capability is woven through the experience, from local models to agentic workflows and creative tools. That gives PC makers a new design space and gives software developers a larger canvas for building experiences that feel more adaptive, useful, and personal.

The Upgrade Feeling

AMD’s Personal AI keynote captures a shift that feels bigger than adding another AI feature to the PC. The idea is to make intelligence part of the machine itself: close to the user, aware of context, ready to help, and connected to the tools that turn ideas into results. If that direction continues to mature, the upgrade people notice may not only be a faster computer. It may be a computer that feels more capable of understanding what they want to create and helping them get there.

ThinkCentre X Ultra Brings Agentic AI Into a 1.6L Desktop

Lenovo introduced the ThinkCentre X Ultra at Innovation World during IFA 2026 on September 3, 2026.

The new system is built around a simple idea: substantial local AI capability does not need a large desktop tower. ThinkCentre X Ultra fits into a 1.6-liter chassis measuring 183 × 183 × 51mm, yet Lenovo positions it as a new class of desktop for the agentic AI era.

That combination makes the launch interesting. The system is not only compact. It is designed around high-memory local AI, developer tooling and a cluster-ready architecture that can connect several units together.

Up to AMD Ryzen AI Max+ PRO 495 Powers the System

At the top of the configuration range, ThinkCentre X Ultra uses AMD Ryzen AI Max+ PRO 495.

AMD lists the Ryzen AI Max+ PRO 495 with 16 Zen 5 CPU cores and 32 threads, while Lenovo pairs the processor with integrated Radeon 8065S graphics and an NPU rated at up to 55 TOPS.

That creates a compact platform with CPU, GPU and NPU resources available inside one system. For local AI development, those compute engines can support different parts of the workflow while keeping the machine small enough to sit almost anywhere on a desk.

Up to 128GB of Unified Memory Is the Real AI Headline

ThinkCentre X Ultra supports up to 128GB of onboard LPDDR5X unified memory.

For local AI, memory capacity is one of the most important parts of the hardware story. A larger memory pool gives the system room for bigger models, longer working contexts and more demanding agent workflows.

Lenovo also allows up to 96GB of that unified memory to be allocated as dedicated graphics memory for the integrated Radeon 8065S graphics. That gives the graphics engine a very large working pool for AI workloads while keeping the platform inside a compact integrated design.

The Memory Runs at Up to 8533MHz Across Four Channels

Lenovo specifies the onboard LPDDR5X memory at up to 8533MHz with four-channel support.

The combination of capacity and bandwidth is designed to keep large local workloads moving efficiently through the system. For AI developers, that matters because model execution involves constant movement of weights, context and intermediate data between memory and compute resources.

ThinkCentre X Ultra is therefore not simply a small office PC with extra memory. Its memory architecture is central to the local AI role Lenovo has designed for it.

Four ThinkCentre X Ultra Systems Can Become One AI Platform

The standout feature is the cluster-ready architecture.

Lenovo says up to four ThinkCentre X Ultra systems can be connected into a unified platform. The goal is to expand the compute and memory resources available to AI workloads beyond one compact desktop.

That changes the product from a single small PC into a building block. A developer can start with one system and use several systems together when the workflow grows.

The Cluster Is Designed for Larger AI Models

Lenovo explicitly connects the four-system architecture with the ability to run larger AI models.

Each ThinkCentre X Ultra brings its own compute and memory resources into the broader platform. For teams experimenting with local generative AI, that creates a path from one compact workstation toward a more substantial local compute environment.

The most interesting part is the form factor: the expansion happens by adding another 1.6L system rather than moving immediately to a large traditional server or workstation footprint.

Longer Context Windows Are Part of the Cluster Story

Lenovo also says the clustered platform can support longer context windows.

Long context is increasingly important for agentic AI. Coding agents may need to work across large repositories, research agents may process many documents, and business agents may need a substantial amount of project material available during one workflow.

ThinkCentre X Ultra is designed to give those workloads access to more local compute and memory as the deployment scales from one system to several.

Multi-Agent Workflows Are a First-Class Target

Lenovo is positioning ThinkCentre X Ultra directly for multi-agent workflows.

Instead of one assistant performing one task, agentic systems can use several specialized agents working in parallel. One can plan, another can analyze documents, another can write code and another can prepare a final result.

The cluster-ready design gives those concurrent workloads a local hardware platform that can grow with the number of agents and the amount of work being handled.

The Platform Can Handle Multiple AI Requests at Once

Lenovo also highlights simultaneous AI requests as part of the system’s scaling story.

That is useful for shared local AI environments where several applications, agents or users may need model inference at the same time. A multi-system ThinkCentre X Ultra setup can provide a broader local compute pool for those requests.

This is where the four-node concept becomes more than a spec-sheet feature. It gives local AI a way to become a shared service inside a compact business or development environment.

AMD Ryzen AI Developer Center Is Integrated

ThinkCentre X Ultra is integrated with AMD Ryzen AI Developer Center.

Lenovo says this gives users access to preconfigured AI tools, models and workflows across Windows and Linux. That software layer is important because powerful hardware becomes much more useful when developers can reach working tools and models quickly.

The integration is designed to shorten the path from opening the system to experimenting with local AI applications.

Windows and Linux Are Both Part of the Developer Story

Lenovo supports Windows 11 as well as Linux options for ThinkCentre X Ultra.

The specification list includes Windows 11 Pro and Home, Linux AMD AI OS and Ubuntu certification. Combined with AMD Ryzen AI Developer Center, that gives developers flexibility in how they build local AI projects.

A Windows-focused team can stay inside its existing environment, while Linux-oriented AI developers can work with the toolchains they already use.

Up to 8TB of High-Speed SSD Storage Fits Inside

ThinkCentre X Ultra supports up to two 4TB M.2 SSDs, creating up to 8TB of internal solid-state storage in the compact chassis.

Local AI projects can quickly accumulate models, datasets, embeddings, source repositories and generated assets. Large internal storage gives developers room to keep more of that material close to the compute platform.

It also reinforces the idea that ThinkCentre X Ultra is intended to operate as a serious local AI workstation rather than only as a thin client for cloud services.

10GbE Gives the Desktop High-Speed Wired Networking

Lenovo includes 10-gigabit Ethernet in the ThinkCentre X Ultra port selection.

The rear panel includes a 10GbE RJ-45 connection, and the optional punch-out port can also be configured with another 10GbE interface. High-speed wired networking is a natural fit for a desktop designed around local AI, large files and multi-system workflows.

It gives the small chassis connectivity that matches the scale of the compute and memory inside it.

Thunderbolt 4 and Modern Display Outputs Expand the Workspace

The rear I/O also includes two Thunderbolt 4 ports, DisplayPort 2.1 and HDMI 2.1.

That gives ThinkCentre X Ultra a broad set of options for displays, high-speed peripherals and external workflows. The front adds two USB-C ports and a headset connection, keeping frequently used ports within easy reach.

For a system that can act as both a local AI node and a daily workstation, that balance of compute and connectivity makes the compact design more versatile.

Wi-Fi 7 Adds High-Speed Wireless Connectivity

ThinkCentre X Ultra also supports Wi-Fi 7 and Bluetooth 5.4.

That gives the desktop modern wireless connectivity alongside its high-speed wired networking. For flexible office layouts, development labs and creative workspaces, the system can fit into different network arrangements without turning its small footprint into a cabling project.

The result is a compact machine that can sit quietly in a workspace while staying connected to modern peripherals and infrastructure.

Adaptive Lighting Turns System Activity Into Visual Feedback

Lenovo adds a visual touch with Adaptive Lighting.

The feature transforms system activity into real-time visual feedback, giving users a quick way to see the state of the machine at a glance. That is especially fitting for an AI workstation that may continue processing local workloads while the user is focused on something else.

The lighting becomes part of the interface between the physical machine and the background compute activity happening inside it.

The Thermal Design Is Built for Sustained Work

Lenovo designed the cooling system around sustained AI workloads while keeping the chassis compact.

The company says the thermal design supports reliable and quiet operation during extended workloads. That is important for a desktop intended to sit directly in a workspace and continue running local inference, agent tasks or development workloads over longer periods.

The engineering goal is clear: keep the local AI capability close to the user without giving up the compact 1.6L form factor.

Enterprise Features Sit Alongside the AI Hardware

ThinkCentre X Ultra also includes Lenovo ThinkShield, AMD PRO technologies and AMD DASH manageability.

That positions the system for professional environments where local AI hardware needs to fit into existing device-management practices. Lenovo also lists discrete TPM 2.0, TCG certification and FIPS 140-2 certification among the platform’s security features.

The AI workstation is therefore designed as part of a managed business fleet as well as a high-performance local development machine.

A 2kg Starting Weight Keeps the System Truly Compact

ThinkCentre X Ultra starts at 2kg while fitting into a chassis just over seven inches wide and deep.

That physical scale is part of what makes the four-system idea interesting. Several nodes can provide a substantial local AI platform without requiring the footprint normally associated with multiple full-size workstations.

For development teams or offices where desk and lab space matter, the form factor becomes part of the compute strategy.

Lenovo Plans Availability From November 2026

Lenovo says the ThinkCentre X Ultra will be available starting in November 2026.

That puts the product on a near-term path from IFA announcement to commercial availability. For developers and businesses building more local AI into their workflows, the system represents a new option that combines compact hardware, large unified memory and a multi-node scaling model.

The launch also expands Lenovo’s ThinkCentre family further into dedicated local AI infrastructure.

The Bigger Idea Is a Modular Local AI Desktop

ThinkCentre X Ultra is most interesting when viewed as a modular local AI building block.

One 1.6L machine can serve as a compact AI workstation. Several can become a larger platform for models, contexts, agents and concurrent requests. The same product therefore spans individual development and small-scale local AI infrastructure.

That is a useful direction for personal and business AI because it gives compute a physical form that can grow in small, manageable steps.

The Upgrade Feeling

Lenovo ThinkCentre X Ultra takes the idea of a mini PC much further than simple space saving.

Up to 128GB of unified memory, Ryzen AI Max+ PRO 495, Radeon 8065S graphics, AMD Ryzen AI Developer Center and a four-system cluster-ready architecture turn the tiny chassis into a serious local AI platform.

The upgrade is the ability to start small and scale physically. One box can be a powerful local AI workstation. Four boxes can become a broader platform for larger models, longer contexts and multiple agents working at the same time.

That makes the ThinkCentre X Ultra feel less like a miniature desktop and more like a new modular form of local AI infrastructure.

Project Zenith Starts With a Different Kind of Windows PC

Microsoft announced Project Zenith on September 4, 2026 as a ready-to-code Windows experience built around developer-class devices.

The idea is simple: combine high-memory hardware with a Windows 11 setup that already reflects the way developers work. Instead of treating the operating system, development tools and local AI hardware as separate layers that only meet after setup, Project Zenith brings them together from the beginning.

Microsoft says the first Project Zenith systems will arrive with AMD Ryzen AI Halo, followed by additional devices from OEM and silicon partners in the coming months.

That makes Project Zenith more than one reference machine. It is a Windows experience intended to appear across a broader class of developer-focused PCs.

64GB+ of Unified Memory Is Part of the Baseline

Microsoft defines the Project Zenith hardware class around at least 64GB of unified memory and memory bandwidth of 250GB/s or more.

Those two numbers explain why the project is closely tied to local AI development. Modern coding models and agent workflows can require large working sets, especially when they are handling source code, project context, tools and multiple steps at the same time.

A large unified memory pool gives the system more room to keep model data and application state close to the compute hardware. Project Zenith uses that hardware foundation as the starting point for the Windows developer experience rather than treating it as an optional upgrade later.

30B+ Parameter Models Can Run Locally and Unmetered

Microsoft says Project Zenith devices are designed to run models with more than 30 billion parameters locally and unmetered.

That changes the role of the developer PC. A machine can become a place where coding models run continuously as part of the local workflow, giving developers another compute layer alongside cloud services.

Local inference is especially interesting for iterative development. A coding agent can be available while the developer edits files, tests ideas and moves through a project. The computer becomes both the development environment and part of the AI execution environment.

AMD Ryzen AI Halo Is the First Hardware Platform

Project Zenith will first become available with AMD Ryzen AI Halo.

AMD introduced Ryzen AI Halo as a developer platform for local AI and agentic workloads. The platform is built around high-capacity unified memory and a software stack designed to help developers run AI models directly on the device.

The partnership gives Project Zenith a hardware platform that already targets the same core idea: a developer computer with enough local AI capacity to become an active part of the application-building workflow.

Microsoft also says more Project Zenith devices from OEM and silicon partners are planned, so the Windows experience is designed to extend beyond one hardware family.

The Windows Setup Is Ready for Development From the Start

The software side of Project Zenith is just as important as the hardware.

Microsoft says these devices ship with a preconfigured Windows environment for development and a curated set of tools covering languages, runtimes, source control and productivity.

Windows Terminal and Visual Studio Code are pinned to the taskbar by default. That detail captures the overall philosophy of the project: the first screen a developer sees should already feel like a development machine.

Project Zenith turns setup into part of the product experience instead of leaving every developer to rebuild the same baseline manually.

File Explorer Is Preconfigured for Coding Work

Project Zenith also adjusts Windows itself for development.

Microsoft says File Explorer is configured to show file extensions, hidden files, the full path in the title bar and the details pane. Long-path support is enabled as well.

These settings make project structure more visible and put technical file information closer to the surface. For developers moving between repositories, build directories, configuration files and generated assets, that creates a more direct working environment from the first boot.

Search, Start and the Taskbar Follow the Same Developer Baseline

The developer configuration continues through Search, Start and the taskbar.

Microsoft says Command Palette is enabled in Search and Start, while the broader Project Zenith setup is designed around a focused developer workspace.

The result is a Windows experience where common development entry points are already present and easy to reach. Project Zenith keeps the familiar Windows shell while tuning the default environment around coding, navigation and command-driven workflows.

WSL Is Part of the Core Development Story

Windows Subsystem for Linux has become a central part of Microsoft’s developer platform, and Project Zenith builds directly on that foundation.

WSL lets developers run Linux environments and tools alongside Windows. Microsoft open-sourced WSL in 2025 and has continued integrating it more deeply into the operating system.

For Project Zenith, that means the local AI workstation can support Windows-native development and Linux-first toolchains from the same machine. A developer can work across ecosystems while keeping the hardware and operating-system experience unified.

WSL Containers Bring Linux Containers Into Windows

Microsoft is also bringing WSL containers into the developer experience.

WSL containers provide a built-in way to create, run and interact with Linux containers directly on Windows. That gives Project Zenith another important layer for modern software development because containerized workflows are common across AI, backend services, tooling and deployment pipelines.

The combination of Windows, WSL and containers gives developers several execution environments on one workstation, all sitting on top of the same high-memory local AI hardware.

Project Zenith Is Designed for the Agent Era

Microsoft connects Project Zenith directly to agentic software development.

Coding agents increasingly work across files, tools, terminals and multi-step plans. They can keep running while a developer continues other work, and they can call local models as part of that process.

Project Zenith gives those workflows a natural home: high-memory hardware for local inference, Windows tools for development, WSL for Linux workflows and platform capabilities for building and running agents.

The workstation becomes an environment where the developer and the agent can work side by side.

Microsoft Execution Containers Add an OS-Level Agent Foundation

At Build 2026, Microsoft introduced Microsoft Execution Containers, or MXC, as a policy-driven execution layer for agents across Windows and WSL.

Project Zenith devices benefit from those Windows platform investments from day one. MXC gives developers a way to define the environment an agent can use, while Windows applies those policies at runtime.

For developer-class hardware, this creates a useful pairing: local AI compute can run directly on the machine, while the operating system provides dedicated primitives for agent execution and management.

Agent Identity and Manageability Are Built Into the Windows Direction

Microsoft is also building agent identity and enterprise manageability into Windows.

The company has described a model where agent activity can be associated with a dedicated local or cloud-backed identity, while tools such as Microsoft Entra and Intune can participate in management.

Project Zenith inherits that broader Windows platform direction. For developers building agentic applications, the machine is therefore positioned as both a local compute platform and an operating-system environment designed specifically for the way agents execute real work.

The Hardware and Software Are Being Designed as One Developer Experience

This is the most important part of Project Zenith.

The project connects device memory, memory bandwidth, local AI models, developer tools, Windows settings, WSL, containers and agent platform features into one baseline.

A developer workstation has traditionally been assembled layer by layer. Project Zenith takes a more integrated approach: the device class and the Windows configuration are planned together.

That makes the hardware specifications meaningful beyond benchmarks. The memory and compute are there to support the software experience Microsoft is building around them.

Project Zenith Builds on Windows Developer Configurations

Microsoft has already been moving toward a developer-optimized Windows baseline through Windows Developer Configurations.

At Build 2026, the company made those configurations generally available through WinGet, with a setup that can prepare tools and developer-focused Windows settings through one command.

Project Zenith takes that idea into a device-class experience. Instead of beginning with a general PC and applying a developer configuration later, the new systems are intended to arrive with the development experience already in place.

It is the same direction expressed through hardware, operating-system defaults and local AI capacity together.

Local AI Gives the Developer PC a New Role

The ability to run 30B+ parameter models locally gives the workstation a role that extends beyond editing and compiling code.

The same machine can host coding intelligence, agent sub-tasks and other model-driven tools directly on the device. That creates a richer local development loop where code, context, tools and inference can all live close to the project.

Cloud models remain part of modern development, and Project Zenith adds another powerful layer: substantial local model capacity that is available directly from the workstation.

The Experience Still Leaves Room for Personalization

Project Zenith provides a curated starting point while preserving the ability to extend and personalize the environment.

Microsoft says developers can continue choosing the tools, languages and frameworks that fit their work. The project is about beginning from a strong developer baseline rather than defining one fixed workflow.

That balance matters because software development is deeply personal. One developer may live in Visual Studio Code and WSL, another may add specialized IDEs, local model runtimes or custom terminal tools. Project Zenith gives each of them a prepared foundation to build on.

More OEM and Silicon Partners Are Coming

AMD Ryzen AI Halo is the starting point, and Microsoft says Project Zenith will expand to more devices from OEM and silicon partners in the coming months.

That gives the project room to become a broader Windows developer hardware category. Different devices can offer different physical designs and performance tiers while keeping the same ready-to-code promise.

The shared idea is consistent: developer-class hardware, a prepared Windows environment, strong local AI capability and Windows platform support for modern agent workflows.

The Upgrade Feeling

Project Zenith is interesting because it treats the developer PC as a complete system rather than a blank machine waiting to be configured.

Microsoft is pairing high-memory local AI hardware with a Windows experience that already understands coding, WSL, containers, agents and the tools developers reach for first.

The result is a new kind of starting point: turn on the machine, open the development environment and begin building with substantial local AI compute already part of the workstation.

That is the upgrade. The PC is becoming both the place where software is written and one of the places where the intelligence inside that software can run.

Google Gemini 3.8 Flash is a production-ready AI model built for long-horizon software engineering, autonomous agents and complex workflows, with a 1M-token context window and a broad set of built-in tools.

The Short Version

Google has launched Gemini 3.8 Flash, a new production-ready model built for long-horizon software engineering, autonomous agents and complex multi-step workflows. Google describes it as its most intelligent Flash model yet. It combines a 1 million-token context window with built-in tools for code execution, file search, function calling, Search grounding, Google Maps grounding, structured outputs and computer use in preview.

Flash Is Becoming an Agentic Workhorse

Gemini 3.8 Flash pushes Google’s Flash line deeper into agentic work. The model is designed for tasks that continue across many steps rather than ending after one prompt and one answer. That makes it a natural fit for coding agents, research workflows, application assistants and systems that repeatedly plan, call tools, inspect results and continue working.

Built for Long-Horizon Software Engineering

Google positions long-horizon software engineering as one of the core strengths of Gemini 3.8 Flash. The model is designed to stay engaged across larger coding jobs that involve several files, multiple tool calls and a sequence of related decisions. For developers, this points toward AI that can participate in a broader slice of the software workflow instead of focusing only on isolated code snippets.

Autonomous Agents Are a First-Class Use Case

Gemini 3.8 Flash is also engineered for autonomous agents. These systems can break a goal into steps, select tools, inspect their own progress and continue until a larger task is complete. Google is clearly treating agent orchestration as a central part of the model’s identity, which makes 3.8 Flash especially relevant for the next generation of AI-powered applications.

A 1 Million-Token Context Window

The model supports an input context window of 1,048,576 tokens. That gives developers a large working space for source code, documentation, long conversations, reports, project files and other context-heavy material. A large context window becomes particularly useful when an agent needs to keep many connected pieces of information available throughout a multi-step workflow.

Up to 65,536 Output Tokens

Gemini 3.8 Flash supports up to 65,536 output tokens. That creates room for substantial generated work such as detailed technical reports, large code changes, structured plans and long-form analysis. Combined with the 1 million-token input window, the model is set up for workflows where both the source material and the resulting output can be large.

Multimodal Inputs Are Built In

Google lists text, images, video, audio and PDFs as supported input types for Gemini 3.8 Flash. That means one agent can reason across several kinds of information without every workflow being reduced to plain text first. For applications that combine documents, screenshots, media and written instructions, this gives the model a much richer view of the task.

Code Execution Can Be Part of the Workflow

Gemini 3.8 Flash supports code execution as a built-in capability. This gives an application a way to move from reasoning about a technical task to running computations or validating generated logic inside the workflow. In agentic systems, that connection between thinking and execution can make the model more useful for data tasks, technical analysis and software development.

Computer Use Is Available in Preview

Google also lists computer use as a preview capability for Gemini 3.8 Flash. Computer use allows an AI system to interact with graphical software and interfaces as part of a larger task. Combined with planning and tool use, it points toward applications that can move through real digital workflows rather than operating only inside a chat box.

Function Calling Supports Connected Applications

Function calling is supported, giving developers a direct way to connect Gemini 3.8 Flash with application logic and external tools. An agent can decide when a function is needed, request the appropriate action and use the returned information as part of the next step. This is one of the core building blocks behind practical AI assistants that can work with live systems.

File Search Helps Agents Work Across Project Material

File search is another built-in capability. For agents working with project documents, technical references or large collections of material, file search can provide a direct retrieval layer inside the model workflow. That helps turn a large document set into active working context instead of something a user has to manually copy into prompts.

Search Grounding Connects the Model to Fresh Information

Gemini 3.8 Flash supports grounding with Google Search. For applications that need current public information, this gives the model a path to bring fresh web context into its reasoning process. Grounded search is especially useful for research agents, information assistants and applications that need to combine model reasoning with up-to-date external material.

Google Maps Grounding Opens Another Data Layer

The model also supports grounding with Google Maps. That creates interesting opportunities for applications involving places, travel, business discovery and geographic context. When combined with agentic planning, Maps grounding can become one more specialized information source that an AI system can call as it works through a real-world task.

Structured Outputs Help Applications Stay Organized

Structured outputs are supported in Gemini 3.8 Flash. This allows developers to request predictable machine-readable response formats for application workflows. Agents often need to pass results from one step to another, so structured outputs can make it easier to turn model responses into data that software can reliably process.

Thinking Levels Can Be Tuned

Google provides low, medium and high thinking levels for Gemini 3.8 Flash. This gives developers a way to shape how much reasoning effort the model applies to different classes of tasks. A lightweight interaction and a complex multi-step engineering job can therefore use different reasoning settings while staying on the same model.

URL Context Expands What an Agent Can Work With

URL context is supported as well. This gives applications another convenient way to bring external material into a task without manually reformatting everything into a prompt. For research, documentation and web-based workflows, direct URL context can help an agent move more smoothly between source material and generated work.

Caching Supports Repeated Workflows

Gemini 3.8 Flash supports caching, which is useful when an application repeatedly works with the same large body of context. Long-running agents often revisit project instructions, codebases or reference material across several steps. Caching gives developers another tool for building persistent workflows around substantial shared context.

Gemini 3.8 Flash Is Generally Available

Google lists Gemini 3.8 Flash as generally available and ready for production use. The stable model ID is gemini-3.8-flash. That production status matters for developers because Google is positioning the model for real applications, agent systems and enterprise workflows now.

Google AI Studio Is One Starting Point

Developers can start working with Gemini 3.8 Flash through Google AI Studio and the Gemini API. AI Studio gives builders a direct environment for testing prompts and model behavior, while the API provides the path into custom applications. This makes the new Flash model immediately accessible to both rapid experimentation and production development.

Gemini Enterprise Adds a Business Deployment Path

Google is also making Gemini 3.8 Flash available through Gemini Enterprise. That gives organizations a deployment path for agentic and multi-step workflows using Google’s enterprise AI platform. The same model can therefore sit behind individual developer experiments and larger managed applications.

Antigravity Uses Gemini 3.8 Flash by Default

Google’s documentation says the Antigravity agent and Antigravity SDK use Gemini 3.8 Flash by default. That is a strong signal about where Google sees the model fitting: at the center of agent workflows that need planning, tool orchestration and sustained work across multiple steps.

The Gemini App Is Part of the Rollout

For consumers, Google says Gemini 3.8 Flash is available to Google AI Pro and Ultra subscribers in the Gemini app. This gives the model a consumer-facing route alongside the developer and enterprise paths, bringing its new reasoning and agentic capabilities into Google’s broader AI ecosystem.

AI Mode in Google Search Also Gets 3.8 Flash

Google is also bringing Gemini 3.8 Flash to AI Mode in Google Search for Google AI Pro and Ultra subscribers. That puts the model’s reasoning capabilities directly inside one of Google’s most widely used information products and shows how the Flash line is becoming part of more than standalone AI tools.

Gemini in Sheets Is Included

Gemini 3.8 Flash is also available in Gemini in Google Sheets for eligible subscribers. Spreadsheet work is a natural place for reasoning, structured data and multi-step assistance to come together. The inclusion of Sheets shows how Google is extending the model into everyday productivity workflows as well.

Google Demonstrated an Entire 3D Game From One Prompt

One of Google’s launch demonstrations shows Gemini 3.8 Flash building a functional 3D game from a simple prompt using a looping instruction inside Google Antigravity. The demo combines puzzles, environmental storytelling and generated textures, providing a vivid example of the model working through a creative software task rather than producing only a short piece of code.

A DOS-Style Google Maps Demo Shows Its Range

Google also demonstrated Gemini 3.8 Flash creating a playable DOS-style version of Google Maps from a single prompt in Antigravity. The result includes locations, directions and Street View. It is a playful showcase, but it also demonstrates the model’s ability to combine interface work, application logic and connected information inside one generated experience.

Hardware Anatomy Turns Device Teardowns Into Interactive 3D

Another Google demo, Hardware Anatomy, uses Gemini 3.8 Flash in Google AI Studio to generate interactive Three.js visualizations of hardware devices. The experience breaks a device into layers that can be explored with a deconstruction slider. It is a strong example of the model combining technical understanding with visual software generation.

Introductory API Pricing Starts at $0.75 Per Million Input Tokens

Google lists introductory Gemini 3.8 Flash pricing at $0.75 per million input tokens and $3.75 per million output tokens through December 31, 2026. That pricing gives developers a clear entry point for experimenting with long-context, tool-using and agentic applications on the new model.

Why This Launch Matters

Gemini 3.8 Flash brings several trends together in one model: large context, multimodal input, built-in tools, configurable reasoning, computer use and a strong focus on autonomous agents. The important shift is that Flash is becoming a workhorse for applications that can keep going, use tools and complete larger digital tasks.

The Upgrade Feeling

The most interesting thing about Gemini 3.8 Flash is how much of the modern AI workflow now fits inside one fast model tier. A developer can give it a large project context, connect functions and search, let it execute code, bring in files, ground its work with live information and build an agent around the same model. That feels less like a simple model update and more like a new foundation for software that can actually work through a task.