Overview

LOCAL LLMs · REAL APPLICATIONS · MEASURED EVIDENCE

What it takes to run local LLMs in real applications.

LLM Lab measures quality, performance, security and operability of local LLMs in real-world applications, Finboard first and Media Search Agent next, across models, runtimes and hardware.

Reference run · Finboard / Qwen 2.5 14B / Metal run evidence

ApplicationFinboardPersonal Finance AppLocal assistant
ModelQwen 2.5 14B4-bit quantizedTransformer × N
RuntimeOllamallama.cppMetal
ExecutionPrefillDecode loopApple GPU
TTFT 449 ms measured
Decode rate 27 tok/s inferred generated tokens ÷ decode seconds
Prompt tokens 47 measured cached prefix 24 measured
Generated tokens 58 measured

run evidence

Four dimensions of local-LLM integration

Each dimension starts from application-level outcomes and extends to the mechanisms, implementation and optimisation beneath them. Each has its own page.

Quality

Does the model perform the application's task reliably, and how is a change in that reliability detected?

  • tool selection and argument binding
  • multi-turn context reliability
  • narration fidelity and failure analysis
  • model and quantization comparison

Performance

Where latency originates, how the model executes, and what the runtime and the GPU actually did.

  • time to first token, prefill, decode and memory
  • transformer blocks and tensor shapes
  • the runtime graph's operators and fusion
  • GPU kernels and the GPU timeline

Security

Whether data, runtimes, tools and model actions remain within explicit, testable boundaries.

  • data flow and prompt exposure
  • runtime isolation and network confinement
  • prompt injection and model protection
  • safety and control: permissions, approvals and limits

Operability

Whether the local LLM stack can be packaged, provisioned, observed, upgraded and recovered as a product dependency.

  • first-run provisioning of the model and the runtime
  • health, diagnostics and the model's lifecycle
  • failure recovery and fallback
  • packaging, upgrades and resource contention

A real-world application, a reference app, and the next domain

The same questions are asked of real-world applications with different failure modes and of a controlled reference app. Each app's status and scenarios come from its catalogue; the live app comes first.

real-world application live

Finboard

Personal Finance App · Local assistant

Finboard is a local-first portfolio look-through desktop app with a local LLM assistant over typed, read-only capabilities. It exercises tool selection, multi-turn context, narration, privacy and confinement, the runtime's lifecycle and inference performance. Finboard keeps its own eval harness and ledger; the Lab consumes what Finboard exports and links the rest.

  • runtime-direct recorded
  • assistant-turn planned
  • narration planned
  • multiturn planned

real-world application planned

Media Search Agent

Media search app · AI search

Media Search Agent would bring a second domain — retrieval, ranking, multimodal context and orchestration over local data — once its generative integration exists. Its scenarios are defined with its first bundle; until then nothing is measured.

reference app planned

LLM Probe

Command-line test app · Controlled test runs

LLM Probe will be a small, deterministic command-line app for exploring the model and runtime stack without a domain: change one variable, observe what happens. It will be the control, not a substitute for a real-world app, and every byte of its prompts will be authored for the Lab.

  • completion planned
  • context-scaling planned
  • tool-call planned
  • long-generation planned

run evidence

Each result is tied to a recorded run

Application, model, runtime, backend, hardware, context and quantization are recorded as explicit variables on every run, each with the provenance its bundle records.

Finboard runtime capture

Reference run · captured 2026-10-22T06:42:27Z

20261022T064227Z-finboard-runtime-direct

One streamed request sent by the collector directly to the runtime Finboard ships, on loopback, with a synthetic prompt and the runtime's default system prompt. It exercises the runtime the app ships; it does not exercise Finboard's prompt assembly, capabilities or narration.

Modelqwen2.5:14b measured
RuntimeOllama measured 0.30.11 measured
Backendmetal inferred
HardwareApple M5 Pro measured
QuantizationQ4_K_M inferred
Context16 384 measured
Prompt47 measured tokenscached prefix 24 measured
Output58 measured tokens

Capture mode lab · text retained false
run page · Performance view · source experiments/public/finboard/20261022T064227Z-finboard-runtime-direct/bundle.json

run evidence

Depth of investigation

Each dimension extends from application symptoms to framework internals and hardware behaviour as the investigation requires. Performance already goes the whole way down.

Performance lenses

From user-perceived latency to the operator, runtime, backend and GPU behaviour behind it. Seven lenses over the same recorded run; the label on each row is the provenance of its evidence in the bundle.

Recorded variables

The same scenario can be compared across models, runtimes, backends and hardware without changing the application. These are the values recorded in the current committed runs; comparisons arrive with a second run.

modelqwen2.5:14b measured
quantizationQ4_K_M inferred
runtimeOllama measured0.30.11 measured
enginellama.cpp b9781 (ggml Metal) inferred
backendmetal inferred
hardwareApple M5 Pro measured24 GB measured
OSmacOS 26.6.2 measured
context size16 384 measured

Begin with the recorded run; continue to the applications.

The Finboard run shows how the same quality, performance, security and operability questions arise in a real application. The LLM Probe will supply the control.