MyBenAI profiles your device's RAM and automatically selects the largest AI model that fits—no manual configuration needed. Understand how the model auto-selection algorithm works, from RAM budget calculation to final model choice.
Why Automatic Model Selection Matters
Devices vary wildly. A flagship iPhone 15 Pro has 8 GB of usable RAM. A budget Android phone from 2022 might have 4 GB total, with only 2.5 GB available at runtime. A 2–3 year old mid-range device has 6–8 GB.
Each model size requires a different amount of memory. Qwen3 0.6B (the smallest) needs roughly 1.2 GB loaded. Qwen3 4B (mid-range) needs ~3.5 GB. Qwen3 8B (flagship) needs ~7 GB. Running the wrong model on your device causes out-of-memory crashes or grinding slowness.
Automatic selection removes the guessing game. When you launch MyBenAI, it checks your device's available RAM, runs the selection algorithm once, and downloads the best-fit model. You get the most capable AI that actually runs smoothly on your hardware.
The RAM Budget Calculation
The algorithm starts by calculating how much RAM the system can safely dedicate to AI inference. This differs between Android and iOS because their memory management and app lifecycle work differently.
Android: MyBenAI uses 45% of the device's total physical RAM. On a Pixel 8 Pro with 12 GB, that's 5.4 GB. On a budget phone with 4 GB, that's 1.8 GB. The 45% threshold accounts for the OS, system services, and other apps that are typically running in the background.
iOS: iOS grants each app a private memory budget that varies by device model. MyBenAI uses 50–70% of that app-specific limit, depending on device capability. An iPhone 15 with 8 GB of system RAM might give MyBenAI 7 GB app-private quota; the algorithm claims 3.5–4.9 GB. An iPhone 12 with less generous memory gets a lower percentage to stay well within safe limits.
Subtract the Headroom
Model inference isn't just the model weight. At runtime, you also need memory for:
- The input tokens (your message)
- Temporary compute buffers (intermediate activations as the model processes)
- Output generation (tokens being written)
- UI, system libraries, and other app overhead
MyBenAI reserves 600 MB as a safety buffer. This ensures that when inference runs, there's enough room for tensors to flow through the model without triggering an out-of-memory error mid-conversation.
So the formula becomes: usable RAM budget (GB) = total memory available – 0.6 GB headroom
Select the Largest GGUF That Fits
Once you have the available budget, the algorithm picks the largest quantized model (GGUF format) that fits within that budget. Larger models generally reason better, have longer context windows, and understand more complex instructions. So the strategy is simple: maximize model size within the memory constraint.
Here's how that maps across device tiers:
- Floor tier (3–4 GB available): Qwen3 0.6B or LFM2 1.2B. Very fast (~20+ tok/s on flagship chips), handles basic chat and simple questions.
- Low tier (4–6 GB): Qwen3 1.7B, Llama 3.2 1B, LFM2 1.2B. Moderate reasoning, solid general knowledge, ~8–15 tok/s depending on device.
- Mid tier (6–8 GB): Qwen3.5 2B, SmolLM3 3B. Better reasoning and instruction-following, ~5–12 tok/s.
- High tier (8 GB+): Qwen3.5 4B, Gemma 3 4B, Phi-4 Mini. Strong reasoning and code understanding, 8–15 tok/s on flagship chips.
- Flagship tier (12 GB+): Qwen3 8B. The strongest reasoning available on-device, competitive with cloud LLMs on many tasks, 15+ tok/s on flagship.
The algorithm iterates through models in descending size order, starting with the largest. The first model whose weight is less than the available budget is selected and downloaded at startup.
Prefer Models With Native Tool Calling
When two models fit the same RAM budget, the algorithm prefers models with native tool calling support (structured output, function definitions). Native tool calling is more reliable than prompting. A model explicitly trained to call functions produces valid JSON more consistently, and inference is marginally faster (no retry loops).
For example: if you have a 5 GB budget, both Qwen3 1.7B and Llama 3.2 1B fit. The algorithm picks Qwen3 1.7B because Qwen was fine-tuned for tool use. Your AI assistant can reliably use calculators, search tools, and device integrations without hanging on invalid function syntax.
Real-World Examples
Example 1: Samsung Galaxy A53 (6 GB total RAM). Android 45% budget = 2.7 GB. Minus 600 MB headroom = 2.1 GB available. The largest model that fits is LFM2 1.2B (~1 GB). MyBenAI downloads and loads this model. Performance: ~8 tok/s, smooth chat, light reasoning.
Example 2: iPhone 15 (8 GB system, 6.5 GB app quota). iOS 60% budget = 3.9 GB. Minus 600 MB = 3.3 GB available. The largest model that fits is Qwen3 1.7B (~1.8 GB). MyBenAI loads this model. Performance: ~12 tok/s, solid reasoning, good tool integration.
Example 3: OnePlus 12 (12 GB total RAM). Android 45% budget = 5.4 GB. Minus 600 MB = 4.8 GB available. The largest model that fits is Qwen3.5 4B (~3.5 GB). MyBenAI loads this model. Performance: ~15 tok/s on the flagship Snapdragon, strong reasoning, excellent tool use.
Example 4: iPhone 11 with smaller models enabled (4.5 GB app quota). iOS 55% budget (conservative for older hardware) = 2.5 GB. Minus 600 MB = 1.9 GB available. Qwen3 0.6B (~700 MB) fits. Performance: ~5–8 tok/s, basic Q&A, best-effort reasoning.
How Models Are Downloaded and Cached
At startup, MyBenAI downloads the selected model from Hugging Face. Models are stored in the app's document directory (on both Android and iOS), so they persist across app restarts. Subsequent launches load the cached model from local storage in under 2 seconds.
If you upgrade your device or gain more free RAM (by closing background apps), you can manually trigger a re-scan in Settings. The algorithm re-evaluates and, if a larger model fits, downloads it. Conversely, if you're running low on space, you can switch to a smaller model to free up storage.
Trade-Offs and Honest Limits
Automatic selection is convenient, but it comes with real constraints. A 0.6B model on a budget phone has materially weaker reasoning than an 8B model on a flagship. It won't solve complex math problems, may misunderstand nuanced requests, and has a shorter context window. For basic chat, reminders, and simple Q&A, it works fine. For detailed coding, research, or analysis, you're limited by model size.
Loading a large model also takes time on first run. On a flagship device with fast storage, Qwen3 8B loads in 4–5 seconds. On a mid-range device with slower storage, it still loads within 6 seconds on cold start. Subsequent launches load the cached model in under 2 seconds. If you need instant startup, smaller models load even faster.
The 600 MB headroom buffer is conservative and accounts for worst-case fragmentation. In practice, you might have 50–100 MB of spare capacity. The algorithm leaves this unused to prevent crashes; trusting it fully would be risky.
Model Re-Selection After System Updates
If your device's OS updates (iOS 17 to 18, Android 13 to 14), available app memory might change. MyBenAI periodically re-checks the RAM budget. If a larger model now fits, it will download it in the background when plugged in and on WiFi. If RAM is tighter, it keeps the current model (no downgrade unless you manually trigger a re-scan).
Checking Your Device's Tier
Want to know which tier your device falls into? Go to Settings > Diagnostics in MyBenAI. You'll see your device's total RAM, usable RAM budget, 600 MB headroom, and the final available budget. This transparency lets you understand exactly why a particular model was selected and whether manually switching to a different size makes sense.
When Auto-Selection Isn't Enough
In rare cases, the automatic choice might not match your needs. If you value speed over reasoning, you can manually downgrade to a faster model. If you're willing to close other apps to free up more headroom, you can try a larger model. MyBenAI's model picker in Settings lets you override the automatic selection, though we recommend trusting the algorithm—it's designed to keep your device stable.
Automatic model selection bridges the gap between the huge variety of mobile devices and the need to run a capable AI locally. Instead of asking "What model should I download?" you just open the app, and it picks the best fit for you. Learn more about how much RAM you need to run AI on your phone, explore the speed and reasoning differences across model families, or check out the full mobile LLM comparison table to understand the trade-offs. Ready to see which model fits your device? Download MyBenAI today.