A practical Apple Silicon benchmark

Find the right local model for the work you actually do.

Not a synthetic leaderboard. This index compares local language models against the everyday work of building products: thinking through decisions, writing code, reviewing risk, and handling confidential information.

The work, not the hype

Four archetypes for an everyday AI stack.

Every model takes the same two practical tests in each category. The question is not “which model wins?” but “which model is the best fit for this task?”

Architect & sparring

System design, work-package planning, and commercially grounded critique.

For: decisions before implementation
  • System Architecture: 50k events/sec notification engine design with discrete work packages, dependency ordering, and testable Given/When/Then criteria.
  • Business Strategy: Rigorous unit-economics critique of flat $49/mo unlimited AI coding SaaS, identifying 3 critical failure modes and margin mitigations.

Coding workhorse

Implementation from clear acceptance criteria and refactoring without avoidable rework.

For: shipping focused code
  • Async Rate Limiter: Full Python AsyncTokenBucket implementation with clean lock management, accurate time replenishment without float drift, and types.
  • Spaghetti Refactoring: Refactoring procedural legacy code with global state into SOLID OOP with repository dependency injection and domain models.

Code & security review

Race conditions, access-control failures, and resilient remediation.

For: catching costly mistakes
  • Concurrency Audit: Detecting subtle race conditions and lock-inversion deadlocks across multi-threaded workers, with thread-safe fixes.
  • Security Audit: Spotting IDOR (Insecure Direct Object Reference) and TOCTOU race conditions in API handlers, providing secure patched code.

Private assistant & tools

Strict structured output and concise synthesis of sensitive source material.

For: local, trustworthy utility
  • Strict JSON Extraction: Converting unstructured escalation text into schema-validated JSON with required keys and zero markdown/preamble.
  • Contract Fact Synthesis: Extracting 4 exact factual liabilities and compliance deadlines from an NDA (liability cap, breach window, encryption, retention).
Interactive results

Choose the trade-off that matters.

Sort by the outcome you care about, filter the kind of model you can run, then select any row to see its full result profile.

Showing the built-in results snapshot.

28 model configurations shown · ranked by overall quality.

#ModelBest fitScoreSpeed

Overall quality against speed

Each point uses the same active filters as the ranking. Select a point to open its full result profile.

Quality is the average of four archetype scores. Speed is average streamed completion tokens per second, measured end-to-end; it includes time spent reasoning before the first visible answer.

Methodology & Test Setup

Transparent enough to challenge.

Each model received the same eight prompts across four everyday engineering archetypes. Evaluation applies deterministic AST syntax checks, strict JSON schema validation, defect pattern matching, and factual extraction alongside focused rubrics for architecture and unit economics. Keyword, defect and fact checks are synonym-aware: common variants such as “dedup” for deduplication or “lock ordering” for lock acquisition order count as a match, so models are scored on the concept rather than one exact phrasing.

Reasoning Models (Active CoT)

Tested with deep chain-of-thought enabled to observe real-world analytical depth and latency trade-offs:

  • Effort parameter: reasoning_effort: "high"
  • Extended ceiling: Tripled to max_tokens: 8,192 to eliminate reasoning truncation where models spend 2k+ tokens thinking before writing code.
  • Dual SSE stream capture: Parsed delta.reasoning_content (Qwen/Bonsai/Ornith) and delta.reasoning (GPT-OSS).
  • Latency split: Measures hidden think time vs. visible answering time.

Standard (Direct Instruct) Models

Tested without internal thinking monologue to measure instantaneous zero-shot synthesis and raw throughput:

  • Direct generation: reasoning_effort: "none" or standard instruct chat template.
  • Zero-shot execution: Direct output without latent CoT scratchpad tokens.
  • Raw generation speed: Direct tokens-per-second metric unencumbered by hidden pre-thinking phases.
  • Head-to-head pairing: Evaluated alongside reasoning variants (e.g. Bonsai Direct vs. High Reasoning).
  • Strict Memory & Graph Purge: Every model transition executes a full unload (lms unload --all) to purge Metal computational graphs and release all Unified Memory.
  • Clean Context & Zero Cache Contamination: Prompts are sent as independent, stateless HTTP requests (messages: [{role: "user"}]) with non-overlapping prefixes, ensuring each test begins at token index 0 in an empty KV cache.
  • Identical Generation Parity: 32,768-token context window (-c 32768), sampling temperature 0.2 across all tests.
  • Deterministic Scoring: Objective pass/fail rules for code compilation, schema adherence, and security vulnerability detection.