The Task APIs: Built-in AI coming to the Web Platform
Chrome ships small, task-specific AI APIs that run entirely on-device — summarize, translate and detect languages without a server, an API key or a per-token bill.
Sandeep Ramgolam
The Task APIs: Built-in AI coming to the Web Platform
There's a family of AI APIs sitting in Chrome right now that most web developers haven't touched. No SDK, no API key, no per-token bill, and nothing leaves the user's machine. You call Summarizer.create() in the console and the browser summarizes text for you, locally.
They're called the task APIs — small, purpose-built APIs for one job each — and three of them have been stable since Chrome 138: Summarizer, Translator and Language Detector. This post is an entry-level tour: what they are, the one pattern they all share, and what to honestly expect before you ship one.
If you read my WebMCP post, this is the same story from another angle: the browser itself is becoming an AI runtime. WebMCP is how agents talk to your site; the task APIs are how your site does AI things itself.
What "built-in" actually means
The model belongs to the browser, not to your page. Chrome downloads it once (the shared foundation model is around 4 GB — Google's docs describe it as Gemini Nano), keeps it on the machine, and every website shares it. Your JavaScript talks to a global object like Summarizer or Translator, and inference runs on the user's own hardware.
That flips the usual economics of AI features:
- Privacy — the text being summarized or translated never leaves the device.
- Offline — once the model is downloaded, everything works with Wi-Fi off.
- Cost — there is no server and no metered API in the loop. Zero.
The Translator and Language Detector don't even use the big model — each downloads its own small task-specific pack (one per language pair for translation), so they work on machines that can't run the 4 GB model.
The one pattern to learn
Every API in the family has the same shape, so learning one is learning all of them. There are four availability states — unavailable, downloadable, downloading and available — and a create() call that can report download progress:
// 1. Ask if the API can work here
const availability = await Summarizer.availability();
if (availability !== 'unavailable') {
// 2. Create a session — this may trigger the one-time model download,
// so it has to happen after a user gesture (a click), not on page load
const summarizer = await Summarizer.create({
type: 'key-points',
format: 'markdown',
length: 'medium',
monitor(m) {
m.addEventListener('downloadprogress', (e) => {
console.log(`Downloaded ${Math.round(e.loaded * 100)}%`);
});
},
});
// 3. Use it
const summary = await summarizer.summarize(longArticleText);
}
Two details worth internalising early:
- A
create()that needs to download a model requires user activation. Wire it to a button, show the progress, and the download UX becomes part of your feature instead of a mystery spinner. - Sessions hold real resources on-device. Create, use,
destroy()— don't hoard them.
The stable trio
Summarizer gives you four summary types from the same input: headline, teaser, tldr and key-points, each in short/medium/long. Output can stream in as it generates, which feels great in a UI.
Loading browser compatibility data...
Language Detector returns candidate languages ranked by confidence:
const detector = await LanguageDetector.create();
const results = await detector.detect('Hallo und herzlich willkommen!');
// [{ detectedLanguage: 'de', confidence: 0.99 }, ...]
Loading browser compatibility data...
Translator works per language pair, and chains naturally with the detector — detect first, then translate:
const translator = await Translator.create({
sourceLanguage: 'de',
targetLanguage: 'en',
});
await translator.translate('Hallo und herzlich willkommen!');
Loading browser compatibility data...
The banners above tell the story at a glance: Baseline limited — shipped and real in Chromium, nowhere else. That's exactly what "use with a fallback" looks like.
These three are real, shipped, production-viable APIs — and built-in AI is already in production elsewhere: Drupal uses the Summarizer for headlines and SEO metadata in its editor, Trip.com generates personalized travel summaries on-device, and Yahoo! Japan moderates comments on-device with the task APIs' bigger sibling, the Prompt API.
The trio in limbo
There are three more — Writer (drafts text from a brief, with tone and length options), Rewriter (shifts tone: more-formal / more-casual) and Proofreader (returns corrections with exact character ranges, so you can highlight them in place).
Here's the honest part, as of Chrome 158 (November 2026): their origin trials ended months ago — Writer and Rewriter at Chrome 148, Proofreader at 145 — and Chrome's own status table now lists all three as developer trials, behind a flag. None of them has graduated to stable. They're early enough that they don't even have web-features entries, so no Baseline banners for these three. On today's stable Chrome the globals simply don't exist. You can still try them behind flags (chrome://flags, search "gemini nano"), but don't build a product feature on them until they graduate. I'm watching the release notes.
This is also your periodic reminder that the whole family is a Chrome (and Edge) thing, incubated in a W3C Community Group — it's not a cross-browser standard. Mozilla and WebKit have both taken negative positions. Firefox and Safari ship none of it. Which is exactly why the availability pattern matters:
Treat AI capability like any other browser feature
The four availability states are the whole progressive-enhancement story. unavailable isn't an error — it's a signal to show your non-AI fallback, the same way you'd treat a missing CSS feature. A "summarize this article" button that only appears when availability() says it can work is a better feature than one that breaks in Firefox.
The hardware bar is real and worth knowing before you commit: the foundation-model APIs want roughly 22 GB of free disk and either a GPU with more than 4 GB of VRAM or the newer CPU path (16 GB RAM, 4 cores). Desktop only for those. The small task-specific models are already escaping that box: Language Detector shipped on Chrome for Android in Chrome 157. Google's broader answer, announced at I/O 2026, is Gemma 197M, an "ultra-efficient expert model" that can transparently back the task APIs on far more modest devices. The API you write against stays the same; the browser picks the brain.
Try them yourself
I've put together a set of small standalone demos — one page per API, plus an availability board that shows the four states and live download progress in your own browser:
github.com/MrSunshyne/chrome-tasks-api-demos
Zero dependencies, no build step — clone it, run any static server, open it in Chrome 138+ and click around. If a chip shows downloadable, clicking it is the whole model-download story happening in front of you.
The task APIs are the shallow end of Chrome's built-in AI pool — and the deep end is interesting: since Chrome 148 there's a full Prompt API stable on the web, an on-device LLM any site can call, with image and audio input and JSON-schema-constrained output. That one deserves its own post. Soon.
