Framework Laptop 13 Pro

The Framework Laptop 13 Pro is a ground-up rebuild of the modular laptop concept, now targeting developers who need local AI inference on a portable machine. At $1,199 MSRP, it delivers 181 total TOPS across CPU, GPU, and NPU, with up to 64 GB of LPCAMM2 memory at 154 GB/s bandwidth. This is the first Framework laptop with Ubuntu certification and Linux pre-installed option, making it a serious contender for engineers who want to run models without a discrete GPU.

The chassis is CNC-machined 6063 aluminum, weighing 1.4 kg at 15.85 mm thin. The 74 Wh battery delivers 20 hours of Netflix streaming, and the 13.5" 3:2 touchscreen at 2880×1920 with VRR from 30–120 Hz covers both coding and media consumption. But the real story is the Intel Core Ultra Series 3 (Panther Lake) silicon and the repairable, upgradeable memory subsystem.

Total AI Compute: 181 TOPS (INT8)

• CPU: 9 TOPS
• GPU (Intel Arc B380, 12 Xe cores): 122 TOPS
• NPU (NPU 5): 50 TOPS

Memory: LPCAMM2 LPDDR5X at 7467 MT/s, up to 64 GB, 154 GB/s bandwidth. This is socketed memory—you can upgrade it later. For AI workloads, memory bandwidth is the bottleneck for token generation, and 154 GB/s is competitive with entry-level discrete GPUs like the RTX 4060 laptop (256 GB/s) while using a fraction of the power.

TDP: 25 W. This is a 25-watt platform that can run local LLMs without a fan screaming. Compare to a 45 W+ laptop GPU or a 150 W desktop card.

Key tradeoff: The integrated GPU (Arc B390) provides 122 TOPS, but it shares memory bandwidth with the CPU and NPU. You are not getting dedicated VRAM. For models that fit entirely in system memory, this works. For models that need 48 GB+, you are out of luck—64 GB max is the ceiling.

This is where the Framework Laptop 13 Pro lives or dies for AI work. With 154 GB/s memory bandwidth and up to 64 GB unified memory, here is what you can expect:

Fits in memory (quantized):

• Llama 3.1 8B (Q4_K_M): ~5.5 GB. Runs comfortably. Expect 15–25 tokens/second via llama.cpp on the GPU.
• Mistral 7B (Q4_K_M): ~4.5 GB. Smooth at 20–30 tok/s.
• Qwen 2.5 7B (Q4_K_M): ~5 GB. Similar performance.
• DeepSeek-Coder-V2 16B (Q4_K_M): ~10 GB. Fits in 16 GB models, runs at 10–15 tok/s.
• Mixtral 8x7B (Q4_K_M): ~26 GB. Needs 32 GB or 64 GB config. Expect 5–8 tok/s.
• Llama 3.1 70B (Q4_K_M): ~40 GB. Requires 64 GB RAM. Expect 2–4 tok/s—usable for batch inference, not interactive chat.

Sweet spot: 7B–16B parameter models at Q4_K_M on the 32 GB or 64 GB config. These run at conversational speeds (15–25 tok/s) with the NPU handling prompt processing and the GPU handling decode.

What does not work: FP16 models larger than 32 GB. Any model requiring CUDA or ROCm—this is an Intel integrated GPU, so you rely on llama.cpp with Vulkan, SYCL, or OpenCL backends. No Flash Attention 2, no tensor parallelism across GPUs.

Multimodal: LLaVA, Qwen-VL, and similar VLMs run at 5–10 tok/s on 7B variants. The 700-nit touchscreen is usable for local vision tasks, but don't expect real-time video processing.

Who should buy this:

• AI agent developers building local tool-use pipelines. The Framework's open EC firmware exposes sensors and system state as scriptable endpoints—your agent can read battery, temperature, fan speed, and lid state. This matters for autonomous agents that need to manage power or respond to thermal conditions.
• Hobbyists running Ollama or LM Studio on Linux. Ubuntu pre-loaded, LPCAMM2 upgradable RAM, and full driver support for the NPU out of the box. No fighting with NVIDIA driver hell.
• Engineers prototyping on-device AI for edge deployment. The NPU 5 at 50 TOPS is comparable to a Qualcomm Snapdragon X Elite NPU. If your target is a laptop-class AI device, this is the development platform.
• Developers who value repairability and upgradeability. The RAM, SSD, Wi-Fi card, and expansion cards are all user-replaceable. You can swap the mainboard later for a future CPU. This is a 5+ year investment, not a disposable machine.

Who should skip this:

• Anyone running 70B+ models at FP16. You need a discrete GPU with 48 GB VRAM.
• Anyone needing CUDA for PyTorch training. This is inference-only on the GPU/NPU.
• Anyone deploying production inference servers. This is a laptop with a 25 W TDP ceiling.

vs. MacBook Pro 14 (M4 Pro, 24 GB unified memory):

• The M4 Pro delivers ~150 GB/s memory bandwidth (comparable), but the M4 Max hits 300 GB/s. For 7B models, both are similar. For 16B+ models, the Mac's higher bandwidth and Metal API optimization give it a 20–30% speed advantage in MLX/llama.cpp. However, the Framework is $500+ cheaper, user-repairable, and runs Ubuntu natively without Asahi Linux workarounds.

vs. ThinkPad P1 Gen 7 (RTX 5000 Ada, 16 GB VRAM):

• The P1 has dedicated 16 GB VRAM with CUDA. For models that fit in 16 GB (7B Q4, 13B Q4), the RTX 5000 Ada delivers 40–60 tok/s—2–3x faster than the Framework's integrated GPU. But the P1 costs $3,500+, weighs 2.3 kg, and has half the battery life. The Framework wins on portability, Linux support, and repairability.

vs. Mac Studio (M2 Ultra, 192 GB unified memory):

• Not a fair comparison. The Mac Studio runs 70B models at 10+ tok/s. The Framework cannot do that. But the Framework costs $1,199, fits in a backpack, and runs for 20 hours. Different class.

When to pick the Framework Laptop 13 Pro:

• You need a daily-driver laptop that also runs local LLMs at reasonable speeds.
• You want Ubuntu with full hardware support out of the box.
• You plan to keep this machine for 5+ years and upgrade RAM/storage/CPU modules.
• You are building AI agents that need to script the hardware directly (fan curves, sensor polling, lid state).

When to skip it:

• You need CUDA for training or inference.
• You run 70B+ models regularly.
• You want the absolute fastest token generation in a laptop (get a MacBook Pro with M4 Max or a gaming laptop with RTX 4090 mobile).