Google Chrome and Microsoft Edge are drawing attention after updated documentation revealed that their on-device artificial intelligence features can require around 20GB of free storage on a computer. The development highlights how web browsers are increasingly turning into AI platforms, with local models being downloaded to Windows PCs so certain AI functions can run directly on the device rather than entirely through cloud servers.
However, the widely reported “20GB AI model” figure needs an important clarification. 20GB is a free-storage requirement, not necessarily the size of the AI model itself. Earlier reporting found Chrome downloading a local AI model of roughly 4GB, while Google’s updated documentation says a compatible system needs approximately 20GB of free disk space before Chrome can download and use its on-device models.
Microsoft Edge has a similar 20GB free-space requirement for its on-device AI model, although Microsoft’s implementation is currently tied to experimental developer versions of Edge and has additional hardware requirements.
Chrome’s 20GB requirement explained
Google has expanded the documentation for Chrome’s on-device generative AI capabilities. The browser can download AI models in the background on compatible systems so that local AI features are available when required.
Google lists approximately 20GB of free disk space as one of the requirements.
The other requirements include an unmetered network connection and sufficient device performance.
This does not mean Chrome will necessarily occupy 20GB with a single AI model.
The distinction is important:
| Requirement | What it means |
|---|---|
| ~20GB free storage | Minimum free space required for eligibility/download |
| AI model size | Not officially stated as 20GB |
| Earlier reported Chrome model | ~4GB |
| Network | Unmetered connection required |
| Device | Must meet Google’s performance requirements |
| Purpose | Running selected AI functions locally |
Google has not publicly explained why the browser needs such a large amount of free space compared with the reported size of the model itself.
One likely explanation is that the 20GB figure provides sufficient headroom for downloading, installing, updating and running local AI components without pushing the computer dangerously close to its storage limit.
Chrome has already been downloading large AI models
The latest development follows reports from earlier this year that Chrome could automatically download a local AI model of around 4GB.
The model is associated with Chrome’s on-device AI capabilities and allows certain functions to operate locally rather than sending every request to Google’s cloud infrastructure.
This approach has several advantages.
Traditional cloud AI
User
↓
Chrome
↓
Internet
↓
Google servers
↓
AI processing
↓
Response
With on-device AI:
On-device AI
User
↓
Chrome
↓
Local AI model
↓
AI processing on PC
↓
Response
Local processing can potentially improve privacy, reduce dependence on an internet connection and reduce latency for supported functions.
But the trade-off is that the AI model has to live somewhere — and in this case, that means the user’s computer.
Why browsers need local AI models
Browsers are increasingly becoming more than tools for displaying websites.
Google and Microsoft are adding AI capabilities directly into their browsers, including features for writing assistance, summarisation, organisation and security.
Chrome’s on-device AI models can support functions such as writing and rephrasing assistance, scam detection, page summaries and tab organisation, according to Google’s documentation.
The basic idea is to allow the browser to perform some AI workloads locally.
Potential advantages of local AI
| Benefit | Explanation |
|---|---|
| Privacy | Some processing can happen on the device |
| Speed | Local inference can reduce network round trips |
| Offline capability | Some features can work without cloud access |
| Cost | Reduces dependence on cloud inference for certain tasks |
| Reliability | AI features may be less dependent on server availability |
| Personalisation | Models can potentially process local context |
However, local AI also creates a new cost for users: storage, memory, processing power and potentially battery life.
The 20GB requirement could affect smaller SSDs
For users with large 512GB or 1TB SSDs, having 20GB of free space may not be particularly concerning.
The situation is different for computers with smaller storage drives.
Consider a Windows laptop with a 128GB SSD.
If the user has only 25GB of free space, Chrome’s AI requirements could become significant.
128GB SSD
Windows + apps
████████████████████████████████████
Available storage
██████ 25GB
Chrome AI eligibility
█████ 20GB
Remaining headroom
█ ~5GB
Having only a few gigabytes of free space can create problems for Windows updates, temporary files, application installations and other system operations.
This is why the 20GB threshold matters even if the AI model itself is considerably smaller.
Chrome’s AI model can be disabled
Google does provide users with a way to disable its local AI features.
Users can go to:
Chrome Settings → System → On-device AI
and turn off the relevant setting.
According to the documentation cited in the reporting, disabling on-device AI also removes the local generative-AI model files and prevents Chrome from downloading them again unless the feature is enabled.
This is important because manually deleting AI model files may not necessarily stop Chrome from downloading them again.
If storage is limited
Open Chrome
↓
Settings
↓
System
↓
On-device AI
↓
Disable
↓
Local AI model removed
↓
Future downloads prevented
Users who have limited storage and do not use Chrome’s local AI features can therefore reclaim space.
Edge has a similar 20GB requirement
Microsoft Edge has also introduced a comparable storage requirement for on-device AI.
Microsoft’s documentation says Edge requires at least 20GB of free space on the drive containing the Edge profile for its local AI model.
But there is an important difference between Chrome and Edge.
The Edge requirement is currently associated with its Prompt API developer preview, rather than being evidence that every stable Edge installation on Windows is automatically downloading a 20GB AI package.
Microsoft’s documentation also lists a requirement of at least 5.5GB of video memory for the Phi-4-mini model used by the feature.
Chrome vs Edge
| Feature | Google Chrome | Microsoft Edge |
|---|---|---|
| Free storage requirement | ~20GB | 20GB |
| Local AI | Yes | Yes |
| Model download | Background download on eligible systems | Triggered through supported preview/API |
| Model size | Not stated as 20GB | Not stated as 20GB |
| Earlier reported model size | ~4GB | — |
| GPU requirement publicly listed | Sufficient device performance | 5.5GB VRAM for Phi-4-mini |
| Connection | Unmetered | Unmetered |
| Current scope | Consumer browser AI | Developer preview for Prompt API |
The comparison shows why headlines suggesting that both browsers are automatically downloading 20GB AI models to every Windows PC can be misleading.
Edge has an automatic storage cleanup mechanism
Microsoft has also documented a safeguard for its local AI model.
If free storage on the Edge profile volume drops below 10GB, Edge can automatically delete the model to ensure there is sufficient space for other browser functions.
This creates a basic storage-management system:
20GB+ free
↓
AI model eligible/downloaded
↓
Storage decreases
↓
Below 10GB free
↓
Edge deletes local AI model
↓
Browser preserves storage
Google’s publicly documented requirements do not currently provide an equivalent 10GB cleanup threshold.
That difference could become important for users and IT administrators managing machines with limited storage.
Why Google and Microsoft are moving AI onto PCs
The shift toward local AI is part of a much broader technology trend.
For years, most generative AI processing happened in data centres.
A user sent a prompt to a cloud server, the model processed it and the answer was returned.
Now technology companies increasingly want AI models to run directly on smartphones, laptops and other devices.
The AI computing shift
PAST
PC
↓
Cloud
↓
Large AI model
↓
Response
NOW
PC
↓
Small local AI model
↓
Local processing
↓
Response
OR
PC
↓
Cloud AI
↓
Large model
↓
Response
The future is likely to involve a combination of local and cloud AI rather than one replacing the other.
Local AI could improve privacy
One of the strongest arguments for on-device AI is privacy.
If a task can be completed locally, sensitive information does not necessarily need to be sent to a remote AI server.
For example, a browser could potentially perform certain writing or classification tasks without transmitting the entire input to a cloud model.
This could be particularly useful for:
- Personal documents
- Private browsing context
- Sensitive workplace information
- Local files
- Personal communications
However, local AI does not automatically guarantee privacy.
The actual privacy benefit depends on what data the application processes locally and what information it continues to transmit to its servers.
Local AI also requires more powerful hardware
Running AI models locally requires computing resources.
Depending on the model and workload, this can involve:
- CPU processing
- GPU resources
- RAM
- Video memory
- Storage
- Battery power
Microsoft’s 5.5GB VRAM requirement for its Phi-4-mini implementation illustrates how hardware requirements can become part of browser features.
This could eventually create a divide between older PCs and newer AI-capable computers.
The rise of AI PCs could benefit from this trend
The PC industry has increasingly promoted AI PCs equipped with neural processing units, or NPUs.
These processors are specifically designed to accelerate AI workloads while using less power than traditional CPU or GPU processing for certain tasks.
The browser AI trend could therefore become another reason for consumers to upgrade their hardware.
AI software
↓
Local AI models
↓
Higher compute requirements
↓
NPU / GPU / RAM
↓
Demand for AI PCs
Browser companies may benefit from this hardware transition because more powerful devices can support more sophisticated local AI functions.
But there is a hidden cost: storage
The AI PC conversation has often focused on processors and NPUs.
Storage is another important consideration.
Large AI models can occupy several gigabytes, and model updates can require additional temporary space.
For a user with a 128GB or 256GB SSD, several gigabytes can be meaningful.
Storage impact
| SSD capacity | 4GB model impact | 20GB free-space threshold |
|---|---|---|
| 128GB | Significant | High |
| 256GB | Moderate | Noticeable |
| 512GB | Lower | Usually manageable |
| 1TB | Small | Generally manageable |
| 2TB | Minimal | Minimal |
The 20GB requirement is therefore more significant for budget laptops and older computers than for modern high-capacity machines.
Browser AI could increase software bloat
Browsers have historically become increasingly resource-intensive.
Modern browsers already consume significant amounts of:
- RAM
- CPU resources
- Storage
- Battery
Adding local AI models creates another layer of software complexity.
Browser
├── Web engine
├── Extensions
├── Cache
├── Security systems
├── Sync data
├── AI models
└── AI runtime
The advantage is more functionality.
The disadvantage is that the browser itself increasingly resembles a software platform rather than a lightweight application.
This could become a problem for enterprise IT
The issue is even more significant for businesses.
Imagine an organisation with:
10,000 Windows computers
If each machine stores a 4GB local AI model:
10,000 × 4GB = 40TB
of storage consumed across the fleet.
Even if the model is smaller or compressed in some configurations, the aggregate storage requirement can become significant.
1 PC
≈ 4GB model
100 PCs
≈ 400GB
1,000 PCs
≈ 4TB
10,000 PCs
≈ 40TB
This makes browser AI model management relevant to corporate IT departments, schools and government organisations.
Administrators may need to decide whether local AI should be enabled across managed devices.
Chrome Enterprise gives administrators more control
Google’s enterprise documentation includes policy controls for its local foundational AI model.
Administrators can control whether Chrome automatically downloads the model.
The default behaviour allows automatic downloading on eligible devices, while organisations can configure policies to prevent the download.
This gives enterprise users more control than individual consumers may initially realise.
For large fleets, administrators can therefore balance:
AI functionality vs storage consumption vs security and compliance requirements.
AI models will likely become more common inside browsers
The Chrome and Edge developments are part of a larger change in browser architecture.
The browser is increasingly becoming an AI interface.
Future browsers could potentially include local models for:
- Summarising webpages
- Writing emails
- Translating content
- Detecting scams
- Organising tabs
- Understanding webpages
- Generating content
- Searching browser history
- Personalised recommendations
- Filling forms
- Assisting with research
The more AI features browsers add, the more important local model management will become.
What happens when multiple apps install AI models?
This is perhaps the biggest long-term storage concern.
A user may have:
- Chrome
- Edge
- Windows Copilot
- Office
- Photoshop
- Other AI applications
- Local developer tools
- AI-enabled games
Each application could potentially maintain its own model.
PC storage
Chrome AI ~GBs
Edge AI ~GBs
Windows AI ~GBs
Office AI ~GBs
Other AI apps ~GBs
─────
Total Potentially significant
If software companies do not standardise model sharing, the same or similar AI capabilities could be duplicated across applications.
That could create a new form of AI software bloat.
The industry may eventually move toward shared models
A possible solution is for operating systems to provide common AI models that multiple applications can access.
Instead of:
Chrome → Model A
Edge → Model B
Office → Model C
App → Model D
the ecosystem could eventually move toward:
Windows AI layer
↓
Shared local models
↙ ↓ ↘
Chrome Office Edge
This could reduce duplicated storage and make local AI easier to manage.
Microsoft’s Windows ecosystem and Apple’s operating-system-level AI frameworks are already moving toward more integrated local AI infrastructure.
The 20GB figure is more warning than crisis
For most users with modern computers, the current requirement is unlikely to cause an immediate crisis.
The bigger significance is what it tells us about the direction of software development.
AI is moving from:
something you access through a website
to:
something that lives inside the software running on your device.
That transition requires local computing power and local storage.
The broader shift
| Earlier software model | AI-first software model |
|---|---|
| Mostly cloud services | Cloud + local AI |
| Lightweight applications | AI-enabled applications |
| Limited local models | Multiple local models |
| Storage focused on files | Storage also used for models |
| CPU-centric | CPU + GPU + NPU |
| AI as separate app | AI embedded everywhere |
What Windows users should know
The most important takeaway is that users should not assume that a headline saying “20GB AI model” means Chrome or Edge will necessarily consume 20GB.
The current documentation indicates that 20GB is primarily a free-space eligibility requirement.
Chrome has previously been reported to download a model around 4GB, while Edge’s current implementation also has its own model and hardware requirements.
Users with limited storage should nevertheless monitor their free space.
If Chrome’s local AI features are not useful, the on-device AI setting can be disabled.
Edge users participating in its developer previews should be aware of the Prompt API’s storage requirements and the automatic cleanup behaviour.
Key data at a glance
| Data point | Chrome | Edge |
|---|---|---|
| Free storage requirement | ~20GB | 20GB |
| Previously reported local model | ~4GB | — |
| Local AI | Yes | Yes |
| Network requirement | Unmetered | Unmetered |
| Hardware requirement | Sufficient performance | 5.5GB VRAM for Phi-4-mini |
| Automatic model download | Yes, on eligible systems | Yes when supported API requires it |
| Storage cleanup threshold | Not publicly specified | Below 10GB |
| Stable consumer rollout | Broader | Current 20GB Prompt API case is developer preview |
What this means for the future of browsers
The Chrome and Edge developments show that AI is becoming a fundamental component of the browser.
Instead of treating AI as an optional website or extension, browser companies are increasingly integrating models directly into the software.
That could eventually make browsers significantly more capable.
But it also means users will need to think about things they previously did not associate with a browser:
How much storage does it use?
What AI models are installed?
When are they updated?
What data is processed locally?
Can the models be disabled?
What hardware is required?
These questions are likely to become normal parts of managing a PC.
Conclusion
Google Chrome and Microsoft Edge are part of a broader shift toward on-device AI, with both browsers now documenting requirements of around 20GB of free storage for certain local AI capabilities.
But the headline that Chrome and Edge can “download 20GB AI models” is somewhat misleading. The 20GB figure represents available free-space requirements rather than proof that the AI model itself is 20GB. Chrome has previously been reported to download a local model of around 4GB, while Google’s current documentation does not disclose a 20GB model size.
Microsoft Edge has a similar 20GB requirement for its on-device AI Prompt API preview, alongside a 5.5GB VRAM requirement for the Phi-4-mini model and an automatic cleanup mechanism when available storage falls below 10GB.
For users with large SSDs, the development may have little immediate impact. For owners of budget laptops and PCs with 128GB or 256GB drives, however, local AI models could increasingly become a meaningful source of storage consumption.
The bigger story is the changing role of the browser. Chrome and Edge are no longer simply windows into cloud-based services. They are becoming AI computing platforms capable of running models directly on users’ devices.
As more applications adopt this approach, the PC of the future may contain not just documents, games and applications, but also a growing collection of local AI models — making storage management, hardware capability and user control increasingly important.
Get the day’s top stories in your inbox
One concise email. No spam, unsubscribe anytime.
