What if an application didn’t need to send every AI task to a massive language model?
Imagine a video editing application that needs to detect faces, identify objects, remove sensitive information, generate captions, and understand speech. Today, developers might reach for a large multimodal model or several cloud APIs to handle these operations.
But many of these tasks are narrow enough to run with much smaller, specialized models.
A model that detects facial landmarks doesn’t need to understand a conversation. A model that identifies profanity doesn’t need to generate paragraphs. A model that recognizes speech doesn’t need to reason about software architecture.
This is the idea behind a collection of small AI models: one specialized model for one specific task, running directly on the device.
The Desertant Models collection brings together 16 models built around this approach. For developers building AI-powered applications, it’s an interesting collection worth understanding.
Why small specialized AI models matter to developers
Consider a mobile application that records a podcast interview.
A single recording can trigger several AI operations:
Clean background noise using Clear.
Convert speech into text using Voz.
Identify the spoken language using Ear.
Improve word-level timestamps using Align.
Identify speakers using Who.
Find interesting segments using Clips.
Generate titles and descriptions using Title.
Remove filler words using Uhm.
Each operation has a dedicated model. Your application can combine them into a complete workflow without sending the recording to a general-purpose cloud AI service.
This architecture has several practical benefits:
Privacy: Audio, images, and text can remain on the device.
Latency: Small models can respond quickly without network round trips.
Cost: Local inference avoids per-request cloud inference charges.
Offline support: Once the required model assets are available, applications can work without an internet connection.
There are trade-offs. Every model has its own supported inputs, languages, accuracy limitations, runtime requirements, and memory footprint. Developers still need to manage model loading, device compatibility, and inference performance.
Meet all 16 specialized AI models
The collection covers audio, text, and computer vision tasks. Here is what each model does and where it fits into an application.
1. Align: Word-level timestamp refinement

Status: Available
Speech recognition systems can produce accurate transcripts while getting individual word boundaries slightly wrong.
Align takes an existing transcript and its original audio, then corrects the start and end timestamps of each word.
For example:
Original:
world(2.61s–3.04s)Refined:
world(2.57s–2.98s)
It works with transcripts from Apple’s SpeechAnalyzer, Whisper, and other speech recognition systems.
Developer use cases: Word-by-word subtitles, karaoke applications, searchable recordings, and video editors that cut footage based on selected words.
The model is approximately 0.7MB and supports nine languages. Its published evaluation reports a reduction in average timing error from 113.5ms to 44.9ms on clean audio.
2. Clear: Speech enhancement

Status: Available
Recordings made using phone microphones often contain background noise, room echo, and inconsistent volume.
Clear processes speech to reduce noise, remove reverberation, and normalize loudness. It produces 48kHz audio and has two variants:
clear-studio: Cleans audio aggressively.clear-natural: Retains room tone, breathing, and some recording texture.
Developer use cases: Podcast recorders, voice messaging applications, meeting recorders, and audio editing tools.
The Apple Core ML model is around 9MB. Desert Ant reports processing a five-minute recording in approximately one second on an iPhone 16 Pro.
3. Clips: Automatic highlight selection

Status: Available
Finding interesting moments in a 60-minute podcast can take longer than recording the podcast itself.
Clips analyzes a transcript, scores candidate sentences, and ranks the best non-overlapping segments.
Developers can control how many clips they want using a percentile threshold. A higher threshold selects fewer highlights, while a lower threshold produces more segments for an automated edit.
It supports 100 languages.
Developer use cases: Podcast clip generators, automatic YouTube Shorts creation, interview highlight extraction, and video editing applications.
Clips works particularly well with Voz for transcription and Title for generating descriptions of selected segments.
4. Ear: Spoken language detection

Status: Available
Suppose someone sends a voice message in Spanish, but your application needs to decide which transcription model to use.
Ear identifies the language spoken in an audio recording. It supports 99 languages and uses approximately 30 seconds of audio to make its prediction.
Developer use cases: Multilingual voice assistants, voicemail routing, voice-message applications, and automatic transcription pipelines.
A useful combination is Ear followed by Voz. Ear identifies the language, and Voz handles transcription.
5. Emo: Context-aware emoji suggestions

Status: Available
Emoji suggestions are common in messaging applications, but they can also improve task managers, calendars, and note-taking tools.
Emo reads short text and suggests relevant emojis.
For example:
“Dentist appointment” → 🦷 🪥 🏥
“Pay my bills” → 💰 💳 🧾
It supports 22 languages and has a vocabulary of 812 everyday emojis, including skin-tone variants.
Developer use cases: Messaging apps, predictive keyboards, calendar applications, and task managers.
Its approximately 5MB Apple model can generate suggestions in under 2ms, making it suitable for interactive text input.
6. Eye: Image classification and ranking

Status: Beta
A photo library can contain thousands of images. Finding screenshots, receipts, duplicate photographs, or pictures with closed eyes requires image understanding.
Eye classifies images and provides tags related to photo types, quality, people, sensitive content, and 558 scenes.
It can also group similar photographs and help select the best image from a burst.
Developer use cases: Photo gallery organization, screenshot detection, receipt classification, image search, and duplicate-photo management.
The model is approximately 48MB in its Apple Core ML format. The project reports 98% precision for screenshot classification at its stated threshold. Eye is currently in beta.
7. Gist: Content topic tagging

Status: Available
Applications that publish large volumes of articles, posts, or videos need a way to categorize content.
Gist reads text and assigns relevant topics from a predefined collection of 36 categories. It supports 101 languages.
For example, an article about index funds could receive a finance tag, while a post about recording podcasts could receive technology and creator economy tags.
Developer use cases: Article categorization, content discovery, recommendation feeds, personal knowledge management, and automatic tagging.
Its model is 74MB, with an English-only version of approximately 15MB. The published evaluation reports that the correct topic appears in the top three predictions 91% of the time.
8. Moderator: NSFW image detection

Status: Closed beta
User-generated content platforms need to screen images before allowing them to appear publicly.
Moderator detects nudity and sexual content in images. It produces separate detection results for exposed nipples, genitals, buttocks, nudity, and sexual activity.
Developers can apply their own moderation policies based on these results.
Developer use cases: Social networks, image-sharing platforms, community applications, and user-generated content systems.
The model is under 8MB in its 6-bit Apple configuration. Its published evaluation reports 87.8% recall and 93.7% specificity.
An important limitation: Moderator covers adult content and is not designed to assess content involving minors. It should support human moderation rather than make final decisions automatically.
💡 Enjoying this article?
Every week day, I publish practical, production-ready deep dives covering Web development, System Design, Open source projects, Tech industry trends and AI Engineering and tools.
9. Redact: Personally identifiable information protection

Status: Available
Imagine building an AI-powered customer support application. Users might submit emails, phone numbers, addresses, or payment details.
Sending that information directly to an external LLM creates unnecessary privacy exposure.
Redact identifies and masks personal information before text leaves the device. It supports 20 detection categories across 27 languages.
For example:
Input:
Email John Smith at [email protected]
Output:
Email [GIVEN_NAME_1] at [EMAIL_1]It also supports reversible redaction, allowing applications to restore original values after processing an LLM response.
Developer use cases: AI chat applications, customer support platforms, document processing, and privacy-conscious LLM integrations.
The Apple model is approximately 11.6MB. Its reported recall is 88.8%, so developers should retain additional validation and privacy controls.
10. Shapes: Hand-drawn shape recognition

Status: Available
Drawing a perfect rectangle or circle with a finger or stylus is difficult on a touchscreen.
Shapes recognizes a single hand-drawn stroke and converts it into clean vector geometry.
It supports five shapes:
Rectangle
Ellipse
Triangle
Star
Line
Developer use cases: Drawing applications, whiteboards, note-taking tools, diagram editors, and digital sketching applications.
The Apple model is approximately 0.2MB and performs recognition in under 10ms.
One limitation: it recognizes one stroke at a time. Multi-stroke diagrams need additional grouping logic.
11. Title: Automatic titles and descriptions

Status: Available
Applications that generate articles, video clips, or transcripts often need short descriptions for their content.
Title generates a title of three to eight words and a description of one or two sentences from text.
It is designed to produce straightforward descriptions without clickbait, hashtags, or emojis.
Developer use cases: Podcast chapter titles, article management systems, video clip descriptions, and content publishing platforms.
The model contains 350 million parameters and uses a 6-bit quantized format. It is distributed as a 350MB-class model and uses Apple’s MLX framework on supported Apple hardware.
An interesting integration is Voz + Clips + Title: transcribe a recording, select highlights, and generate a title and description for each clip.
12. Tongue: Short-text language identification

Status: Available
Language detection becomes difficult when users enter only a few words into a search box.
Tongue identifies the language of short text, even with as few as three words.
It supports 84 languages and has a model size of approximately 2MB.
Developer use cases: Multilingual search, chat applications, language-aware content routing, and localized user interfaces.
The project reports a 0.933 score on three-word FLORES-200 input, compared with 0.887 for a 293MB detector.
When the input is too short to make a reliable prediction, Tongue can return a tie instead of forcing a language choice.
13. Toxic: Hate speech detection

Status: Closed beta
Online communities need to identify hateful, abusive, and threatening messages before publication.
Toxic analyzes text and scores these categories separately, allowing applications to implement different moderation rules.
It supports 23 European languages and has an approximately 80MB Apple model.
Developer use cases: Social networks, community forums, messaging platforms, and comment moderation systems.
Its reported macro F1 score is 0.847 on the seven EU languages covered by its Multilingual HateCheck evaluation.
However, context matters. Quoted hate speech, news reporting, and counter-speech can trigger false positives. Treat Toxic as a moderation aid and route flagged messages for review.
14. Uhm: Filler-word detection

Status: Available
When recording a podcast or presentation, people naturally say “um”, “uh”, and “hmm”.
Removing these manually from a long recording can be tedious.
Uhm analyzes the audio waveform directly and identifies filler words with approximately 20ms timing resolution. It doesn’t require a transcript, which matters because many speech recognition systems omit filler words.
Developer use cases: Podcast editing, interview cleanup, speech coaching, and automatic audio editing.
The Apple model is approximately 45MB. Desert Ant reports analyzing an hour of audio in around 12 seconds on an iPhone 17 Pro.
Its primary limitation is language coverage: it was trained on English, with reported transfer to Spanish, French, German, and Dutch.
15. Voz: On-device speech recognition

Status: Available
Speech-to-text is one of the most common AI features developers integrate into applications.
Voz converts audio into text directly on the device and provides word-level timestamps.
This makes it useful for applications that need searchable transcripts or synchronized captions.
Developer use cases: Meeting recorders, podcast applications, voice notes, transcription tools, and searchable audio archives.
The collection advertises transcription of 10 minutes of audio in approximately two seconds on an iPhone. Its broader product materials also report word-level timestamp support.
16. Who: Speaker identification and diarization

Status: Beta
A transcript becomes much more useful when you know who said each sentence.
Who performs speaker diarization: it identifies different speakers and marks when each person starts and stops talking.
It numbers speakers in the order they first appear and can mark overlapping speech when multiple people talk simultaneously.
Developer use cases: Meeting transcription, podcast editing, interview analysis, video subtitles, and call recording applications.
Its published evaluation reports a 12.6% diarization error rate on AMI meeting recordings. The model is approximately 81MB in float16 format.
Who is particularly interesting when combined with Voz, because you can produce a transcript with timestamps and speaker labels. It is currently in beta.
How developers can integrate these models
The collection is useful because it provides SDKs for different development environments.
According to the documentation, developers can integrate models using:
Swift: iOS and macOS applications.
Kotlin: Android applications.
JavaScript / TypeScript: Browser and Node.js applications.
The JavaScript packages use technologies such as Transformers.js, ONNX Runtime Web, and LiteRT.js, depending on the model.
For JavaScript developers, the official packages are available under the @desert-ant-labs npm scope.
You can explore the integration documentation here:
Pricing and availability
The collection advertises free usage for up to 100,000 monthly active devices per SDK, with unlimited inference per user. Custom licensing is available.
Keep in mind that some models, including Eye, Toxic, Moderator, and Who, have beta or restricted availability. Check their individual documentation before choosing them for production.
What this means for application architecture
The interesting part is how these models can work together.
Consider building a completely on-device podcast processing application:
Audio Recording
|
v
Clear
(Clean the audio)
|
v
Ear
(Detect the language)
|
v
Voz
(Transcribe audio)
|
v
Align
(Refine word timestamps)
|
v
Who
(Identify speakers)
|
v
Uhm
(Detect filler words)
|
v
Clips
(Select highlights)
|
v
Title
(Generate descriptions)
|
v
Finished ContentEach model handles a specific stage. Your application coordinates the workflow and decides how to handle the output.
For example, a developer could build a podcast editor that transcribes recordings, identifies speakers, removes filler words, selects highlights, and generates descriptions without sending the original recording to a cloud AI service.
That is a useful architecture for privacy-conscious applications.
There are engineering considerations, though. Models have different platform support, processing requirements, and language coverage. Some operations can run independently, while others depend on earlier results. You also need to consider model download size, memory usage, battery consumption, and inference scheduling.
My recommendation: Start with one model that solves a clearly defined problem in your application. Measure its accuracy and performance on your target devices before combining it with other models.
Final thoughts
I find this collection interesting because it demonstrates how specialized AI can fit into everyday software development.
Developers often reach for an LLM when they need to add intelligence to an application. That makes sense for open-ended language tasks, but many product features have much narrower requirements.
Image classification, language detection, PII redaction, speech enhancement, and timestamp refinement are examples where a dedicated model can be a practical choice.
You don’t need a general-purpose AI model for every feature.
Sometimes a 2MB language detector or a 0.2MB shape recognizer is exactly what your application needs.
For developers exploring on-device AI, this collection is worth bookmarking.
Thank You for Reading!
I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.
