Alex Grankin takes twelve everyday jobs and asks which local model can handle each one. His answer starts with dictation on an ordinary computer and ends with the limits of autonomous software development.

The 44-minute video is unusually practical. It shows specific requests, successful outputs, and mistakes. Buying the biggest possible machine is a poor starting point. Choose a recurring job, test a model on that job, and buy capacity only when a measured limit gets in the way.

Scope: This follows the complete November 14, 2026 video. Demo results and timings are Grankin’s reports, not independently reproduced benchmarks. Primary documentation was checked on November 22, 2026. Suggested tests below are editorial extensions.

Start with the job, then choose the model

Three kinds of work run through the video:

  • Transform supplied material. Turn speech into text, a receipt into fields, or notes into a courteous email. The input contains most of the answer.
  • Supply missing knowledge. Answer a historical question or research a current product. The system needs reliable memory or an external source.
  • Take actions over time. Organize files or build software. Each step changes what the next step must do, and mistakes can have lasting effects.

That progression explains much of the hardware story. A specialized speech model can do useful work with little memory. A general model needs broader capabilities. An agent, a model running a multi-step task with tools, also needs reliable decisions and controlled permissions.

There is a second progression: a plausible answer, a verified answer, and permission to act on it are three different milestones. Reading a receipt correctly once does not authorize automatic bookkeeping. Generating a working page does not make an application ready for customer accounts.

The twelve jobs at a glance

These are the creator’s November 2026 recommendations and approximate memory tiers. They are a starting map, not guaranteed requirements for every operating system, model build, or context length.

Job Starting point in the video Creator’s memory tier Main thing to check
1. Dictation Handy with Parakeet; optional text cleanup 8 GB Language support and accidental changes during cleanup
2. Recorded calls Small speech model for ordinary audio; Nemotron for overlapping speakers 8 GB / 32 GB Words, speaker labels, and overlap separately
3. Your own voice Ming; Vocello offers a separate Qwen3-TTS graphical workflow 16 GB Consent, pronunciation, and exact model licence
4. Images FLUX.3 klein in Draw Things 24 GB; 16 GB tight Licence, text accuracy, and unwanted edits
5. Photos and scans Qwen 3.5 9B; larger Qwen for harder material 16 GB / 32 GB Every field, source image, and arithmetic
6. Questions Qwen 3.8 27B with deliberate web search; smaller Gemma or Qwen 3.5 9B as alternatives 32 GB; smaller options at 16–24 GB Whether it actually fetched a source
7. Writing The same Qwen; reduced thinking for simple edits; Gemma on smaller machines 32 GB / 16–24 GB Facts, commitments, tone, and additions
8. Documents Qwen with enough context; 9B for shorter files 32 GB / 16–24 GB, workload-dependent Full document versus retrieved excerpts
9. Presentations Source brief to HTML slides 32 GB Numbers, charts, layout, and export
10. Small tools Qwen, a detailed request, and functional checks 32 GB; formulas or short scripts at 16 GB Behavior, persistence, and unsafe edge cases
11. Agents Hermes with a local model and restricted tools 32 GB starting point Isolation, approvals, and recovery
12. Larger applications Prefer a strong hosted coding system for the demonstrated workload Beyond the small-machine recommendations Sustained correctness across the whole project

Memory warning: These demos all ran on one 128 GB M5 Max MacBook Pro. The smaller-machine recommendations are extrapolations, not twelve sets of measurements on different computers.

The exact Qwen3.8-27B and Qwen3.5-9B releases are distinct models. The larger model advertises a native 262,144-token context. That is a supported model limit, not a promise that every computer can run that context. Gemma 4 is a family with several sizes; the video does not establish an exact smaller Gemma checkpoint.

1. Dictation: a small model can remove daily friction

Watch from 1:48.

Grankin splits dictation into two jobs. A speech model hears the words. A text model optionally removes filler and resolves spoken corrections, such as “Monday, no, Tuesday.” That second step can make a transcript easier to use, but it can also change its meaning.

His starting recommendation is Handy, an open-source dictation app, with Parakeet for fast recognition. He also discusses Whisper for broader language coverage and Qwen3-ASR as another accuracy-oriented option. VoiceInk is a paid, Mac-only alternative in his comparison.

Exact checkpoints matter. NVIDIA’s Parakeet TDT 0.6B v3 covers 25 European languages. The v2 release is English-only. Both use CC BY 4.0, which permits commercial use with attribution obligations. Qwen3-ASR lists 30 languages plus 22 Chinese dialects under Apache 2.0. Those dialects should not be counted as 22 additional languages.

Handy’s post-processing documentation includes local and cloud cleanup options. Local speech recognition alone does not keep the final text on-device if cleanup uses a remote provider.

  • What the demonstration establishes: hold a shortcut, speak, release it, and insert the result into an application. This is a bounded, frequently repeated workflow.
  • Why small models fit: speech recognition is a narrower task than running a general assistant. Fast turnaround can matter more than broad reasoning ability.
  • Where mistakes hide: names, abbreviations, dates, spoken corrections, and punctuation. Cleanup can remove a qualification that sounded like a hesitation.

The right test is a short collection of your actual phrases. Include a name, a price, a correction, and a sentence where “do not” matters. Judge the final inserted text, including cleanup, rather than the raw recognition alone.

The video’s “8 GB” tier is an approximate whole-computer recommendation. It does not mean every speech model, cleanup model, and application combination has the same footprint.

2. Recorded calls: getting the words and identifying speakers differ

Watch from 6:05.

A live dictation tool usually follows one speaker. A meeting may contain several people, interrupted sentences, background noise, and simultaneous speech.

Grankin compares small speech models with NVIDIA’s Nemotron 3.5 Transcribe, described in the video as a roughly 22 GB download. His claimed advantage for the larger model appears when people speak over each other. For simpler recordings, the smaller options remain useful and faster.

NVIDIA’s release page confirms speaker-attributed transcription and overlapping-speech support. It lists 40 languages, compared with the video’s “about 45.” The official GGUF package separates decoder and encoder files and documents hardware-specific configurations. Those configurations do not independently establish the video’s exact 32 GB Mac setup. Check the conversion and runtime before treating that tier as a shopping specification.

He mentions MacParakeet as a convenient application for ordinary recordings. He also says the larger model lacked a convenient supported graphical workflow in the apps he examined. Model capability and application support are separate purchasing questions.

Three tests belong on the scorecard:

  1. Transcription: did the system recover the words, especially names, dates, amounts, and negation?
  2. Diarization: did it assign speech to the right anonymous speaker?
  3. Overlap handling: did it preserve both contributions when two people spoke together?

A low word error rate measures transcription mistakes. It cannot, by itself, tell you whether an offer, objection, or instruction was assigned to the right person. A transcript can contain every important word and still misrepresent the meeting.

The demonstration favors Nemotron on the selected overlapping recording. It does not prove that every call needs a larger model. Keep a difficult overlap clip in a test set before paying for more memory.

The suggestion that an unsupported model can be added to an app in “10–15 minutes” also needs restraint. Loading, audio formats, speaker output, packaging, and device support are integration work.

3. Voice cloning: short examples can sound convincing

Watch from 9:50.

The use case is a small correction to a training video. Instead of re-recording the whole passage, generate a replacement sentence in an authorized voice.

Grankin recommends Ming and mentions Vocello for people who prefer a graphical workflow. His example uses a 17-second reference recording. He reports about nine seconds to generate a paragraph containing a price, date, and product name.

There is an important model distinction. The benchmark’s Ming entry links to Ming-3.0-tts-0.5B, released under MIT. Vocello’s own repository says it uses Qwen3-TTS on Apple silicon, not Ming. Vocello is an alternative voice-cloning workflow, not a verified interface for the Ming model.

Grankin finds the result convincing, while acknowledging audible artifacts. Repeated takes may solve an awkward sentence, but those retries belong in the cost and time estimate.

A sensible review checklist includes:

  • Content: does the voice say exactly the approved words, including numbers and dates?
  • Pronunciation: are names, currencies, and abbreviations understandable?
  • Continuity: does the replacement match the surrounding recording’s volume, pacing, and room sound?
  • Permission: is there informed authorization to clone and use this voice?

A locally generated voice is still a biometric likeness. Keep reference recordings and generated files under a retention policy. Avoid using another person’s voice as an unannounced substitute for their participation.

The video compares models using listener-preference results. The Artificial Analysis controlled-voice test uses eight cloned English voices, four US and four UK. Its current scores place Ming and Drama 3 in a tie. That is evidence about this listening test, not a guarantee for a new speaker, language, or long recording.

4. Images: useful results, with licensing and editing caveats

Watch from 13:00.

Grankin tests FLUX.3 klein, using Draw Things, on a menu board, a branded mug, and a sale poster. Black Forest Labs calls the release FLUX 3 Image Klein. He returns to tasks that had caused trouble in an earlier comparison.

He reports correct words and prices in the new menu-board result. The images also reveal the familiar gap between a convincing first impression and a usable final asset. One hand looks strange. An edit can change more than the requested region.

  • Text-to-image: check spelling, numerals, layout, branding, and unwanted visual details.
  • Image editing: compare the whole result with the original. A corrected sign is a failure if the product changed too.
  • Runtime: Grankin reports roughly ten seconds to a minute per image on his machine. Resolution, steps, settings, and hardware change that substantially.
  • Memory: his comfortable recommendation is 24 GB, with 16 GB described as tight when other applications are closed.

His broad statement that only one of the best local image models is available for business use should not become a general licence rule. Permissions attach to an exact model release and its terms. “Open-weight” means downloadable model files with licence terms attached; it does not promise unrestricted commercial use.

The FLUX Kommunity License allows qualifying commercial output generation below $5 million in gross annualized revenue, including affiliates. It also sets conditions for output review or content filtering and legally required disclosures. This is a limited permission, not blanket rights for every commercial model use.

Other local image releases have different terms. FLUX.2 klein 4B and FLUX.1 schnell use Apache 2.0 with commercial permissions. These are counterexamples to a blanket prohibition, not claims that they match the newer model’s output quality.

For a shop menu, generate the visual treatment and place final prices with conventional design tools when possible. Editable text is easier to correct and audit than letters baked into an image.

5. Photos, receipts, and scans: extraction needs a checking step

Watch from 15:58.

Grankin distinguishes a specialist page reader such as GLM-OCR from a general vision-language model, which answers questions about an image. His small general recommendation is Qwen 3.5 9B. He recommends the larger Qwen for harder charts or documents when memory allows.

His examples include a made-up Spanish receipt photographed at an angle, a bar chart without printed values, and a crumpled supermarket receipt. He reports correct extraction on those selected inputs. The larger model gives the same answer more slowly on an easier chart.

That is an argument for testing the small model first. It is also a reminder to separate three stages:

  1. Read the source. Recover text, layout, and visible values.
  2. Interpret the result. Decide which amount is tax, total, tip, or currency.
  3. Commit the record. Write fields into a spreadsheet or accounting system.

The demonstration is strongest on the first two stages. An automated system should check required fields, valid dates, currency, duplicates, and arithmetic before committing records. A calculator should verify the sums.

For a chart without printed values, report estimates and preserve the axis scale. An approximate height should not quietly become an exact financial number.

The video’s GLM-OCR run returns lines rather than the desired table. That is a result of the demonstrated setup, not proof that every OCR workflow must produce unstructured text.

6. Questions: search must actually happen

Watch from 20:00.

This section contains one of the video’s best checks. Grankin asks four different questions: a savings calculation, a Finder shortcut, the opening of Madrid’s metro, and the plot of a nonexistent Ishiguro novel.

Those prompts test different abilities. Calculation should go to a calculator. A computer shortcut can be checked in documentation. Historical details need a source. An invented book tests whether the model accepts a false premise.

He tries the same Qwen model with thinking disabled, thinking enabled, and search available:

  • Without thinking: it handles the simple tasks but misremembers the metro’s date and a station. It rejects the nonexistent novel while sometimes adding unsupported book references.
  • With thinking: the metro answer improves after a reported two minutes and 39 seconds, but a station remains wrong.
  • With explicit search: the date and both stations become correct in his demonstration.

Crucially, enabling search did not initially make the model search. He had to request it explicitly and approve the outgoing query.

Reproduce the integration, not just the toggle. Classic LM Studio supports external tools through MCP, a standard for connecting models to tools. Current Bionic documentation describes a separate app. Its built-in search instructions do not prove which integration the video’s LM Studio setup used.

A connected tool is an available capability, not evidence that the answer used it. Inspect the actual request and retrieved page. A citation that does not support the claim is another failure.

Thinking can help work through information already available. It cannot reliably recover a fact the model never learned or currently misremembers. For changing facts, use a dated source. For private facts, supply the authorized document. For missing facts, allow an explicit “unknown.”

Grankin also reports a harder factual test: Qwen answers about 18 of 100 questions correctly, abstains on about 59, and fabricates the remainder. These are creator-reported benchmark figures for the tested model and setup. They describe factual accuracy and willingness to abstain, separately from general capability rankings.

For 16 or 24 GB machines, he suggests a smaller Gemma with search, or trying Qwen 3.5 9B. A weaker model with verified evidence can still be useful for a narrow question.

Search also changes the privacy boundary. A local model may send search terms containing private details to an external service. Review the query as carefully as the answer.

7. Writing: supplied facts make a tractable local job

Watch from 25:58.

Grankin supplies six notes and five rules for an email to a client called Marta. The model must keep the date and price correct and avoid mentioning a discount. He reports that the selected result follows those constraints.

Another prompt asks for a calm rewrite of an angry invoice email. With thinking off, the response arrives in roughly five seconds. One run adds a phrase about keeping a partnership afloat, although the prompt established no partnership.

That small invention captures the main risk. A rewrite can preserve every number while adding a relationship, promise, apology, or concession the sender never approved.

Use a compact contract for writing tasks:

  • Facts to preserve: names, amounts, dates, and the actual request.
  • Changes allowed: tone, order, grammar, and length.
  • Claims forbidden: invented commitments, discounts, relationships, or explanations.
  • Review: compare the final draft with the supplied facts before sending.

The creator prefers the larger Qwen for constraint-following and describes Gemma as stronger for translation. Treat that as a task-specific comparison. Translation quality needs examples in the actual language pair, especially for legal or technical wording.

His smaller-machine alternative for writing is Gemma at 16 or 24 GB. The same facts-and-commitments review applies.

A smaller model that reliably rewrites a paragraph can be more valuable than a larger one left running for occasional open-ended chat.

8. Documents: the app may have changed what the model saw

Watch from 27:30.

Grankin gives the model a 37-page office contract, described as roughly 31,000 tokens. Tokens are the text pieces a model processes. Context is its available working space for the prompt, documents, conversation, and generated answer.

With a large configured context, his questions cover a second-year fee, late-payment terms, notice before entry, and a rate spanning two sections. He reports five correct answers with section references, including a question about an unstated early-exit fee.

Then he changes one setting: the context drops to 8,000 tokens. The app supplies three retrieved pieces in this run. The fee table is absent, and the same model now says the fee is unstated.

LM Studio’s document documentation confirms the general behavior. Short enough documents enter the conversation in full. Longer ones use retrieval-augmented generation, or RAG: relevant excerpts are selected for the model. The docs do not establish “three chunks” as a permanent rule for every version.

In Grankin’s explanation, the failure begins with missing evidence. The model cannot quote a fee table it never received. Without the original file and retrieval trace, that explanation remains a demonstration-specific diagnosis rather than an isolated causal result.

For important document work:

  1. Check whether the extracted file is readable and complete, including tables and appendices.
  2. Confirm whether the app sends the whole document or retrieved excerpts.
  3. Ask for the exact supporting clause, section, or page.
  4. Include a question that requires combining distant clauses.
  5. Include a fact absent from the document and require an explicit absence answer.

Full-document context avoids this particular retrieval miss. It still leaves extraction errors, overlooked clauses, and unsupported interpretation. Retrieval can work well when its selected evidence is correct.

Setting context to the model’s maximum is a blunt fix. Allocate enough for the actual document, conversation, and answer, then measure memory and speed. A 31,000-token document does not automatically require a 256,000-token allocation.

For shorter files on 16 or 24 GB, Grankin suggests the 9B model. Document length, extracted tables, and the surrounding conversation decide whether that smaller setup is practical.

9. Presentations: generation is one part of the document pipeline

Watch from 31:08.

A two-page brief becomes ten HTML slides with keyboard navigation. Grankin reports that the numbers come from the supplied brief and that the model draws charts. Some labels overlap, some slides waste space, and two comments are added without source support.

His high-thinking run takes about 24 minutes, including eleven minutes before visible output. He attributes much of the delay to a slower execution choice. A low-effort version keeps the facts but uses a plainer design.

For the same prompt, he reports Claude finishing in under two minutes and free ChatGPT in about five. Both preserve the source numbers and have layout defects. An older Opus comparison produces an almost empty chart. These selected runs illustrate trade-offs; the admitted local runtime mistake prevents a controlled speed comparison.

The comparison illustrates three separate qualities:

  • Factual fidelity: do values, labels, and claims match the source?
  • Visual communication: do the charts and hierarchy explain those facts?
  • Artifact quality: do navigation, fonts, layout, and printing work?

A handsome deck can fail the first test. An accurate deck can fail the second. A presentation that works in one browser can still clip during PDF export.

The video says a local model cannot generate a PowerPoint file directly. More precisely, chat text needs software to assemble a valid presentation package. A local workflow can generate structured content or code, then use a document library to create the file.

Choose the output around its next use. HTML is convenient for a browser presentation. A colleague who needs editable slides may need PowerPoint. Either path needs a rendered inspection at the intended screen or page size.

The example brief concerns an IPO. Its figures and timing serve the demo; they are not independently verified financial reporting here.

10. Small tools: a functional test beats a polished screenshot

Watch from 34:17.

Grankin asks Qwen for a budget tracker as a single file. A separate script clicks through it, adds and edits expenses, sets a budget, and tries invalid amounts. He reports passing checks, including an export check, with a visible date-picker defect.

The run takes about 43 minutes. Roughly 28 minutes pass before code appears. Those timings belong to his settings and machine, but they show why “the model fits” is an incomplete usability claim.

The test script is the valuable part of the workflow. It checks whether the page does what the request specified. Visual-preference rankings cannot replace that.

Add checks a successful demo may miss:

  • Persistence: reload the page and reopen the browser. Are records still present?
  • Numbers: test zero, negative values, decimal amounts, and locale-specific formatting.
  • Dates: test month boundaries and ambiguous day/month input.
  • Exports: open the actual exported file in its intended application and check every field.
  • Recovery: confirm that a failed import cannot destroy existing records.
  • Safety: treat generated code as executable software before opening it with sensitive files or network access.

A local page can still load remote fonts, scripts, analytics, or APIs. “It opens from a file on my computer” does not describe all its data flows.

For a small personal tool, a narrow specification and repeatable checks can make local generation useful. Broader claims need broader tests.

At 16 GB, Grankin lowers the expectation to a formula or short script. That can still solve the underlying problem without generating a complete interface.

11. Agents: permission boundaries matter more than confidence

Watch from 37:02.

Grankin uses Hermes Agent to organize a folder of synthetic files. The rules include keeping every file and writing a log. A planted note tries to override those instructions and delete tax letters.

He reports that the job finishes in about five minutes. The agent organizes the files, rejects the planted instruction, and produces a matching log. A filename ends up with a double dot. This is a useful bounded demonstration with a deliberately hostile input.

The planted note is prompt injection: untrusted content trying to become an instruction. Ignoring one example is a successful test case, not proof of general resistance.

His precautions include approvals and a restricted workspace. The implementation matters. Hermes’s security documentation distinguishes command approvals, file-tool write guards, and container isolation. A shell running as your user can have wider access than a file tool’s configured safe root.

Choosing a working directory does not itself create an operating-system sandbox. For real containment, restrict filesystem mounts, credentials, and network access in an appropriate isolated environment. Check every enabled tool’s reach.

A safer first file-organization workflow is:

  1. Work on disposable copies, with an untouched backup outside the agent’s reach.
  2. Generate a proposed move manifest before changing anything.
  3. Reject duplicate destinations and ambiguous filenames in ordinary code.
  4. Approve the exact plan, then execute it without deletion privileges.
  5. Compare before-and-after file inventories and content hashes.
  6. Retain the manifest so the changes can be reversed.

The model can classify and suggest names. Deterministic checks can protect against lost content and collisions.

Finally, inspect every configured model route, fallback, and external tool before calling the system local-only. Disabling one obvious cloud option does not audit the entire workflow.

12. Larger applications: task length changes the economics

Watch from 41:07.

The last job adds databases, authentication, APIs, credentials, and interactions across a larger codebase. Grankin favors a strong hosted coding system for this work. He considers very large local setups possible but difficult to justify for many home users.

His examples of expensive, high-memory machines are a November 2026 comparison. They are not a general minimum specification for writing software locally. Scope, model choice, human supervision, and the amount delegated all matter.

A local model can contribute to a larger application without owning the whole project:

  • explain a function or draft a small change;
  • propose tests for a well-defined interface;
  • extract information from local documentation;
  • transform repetitive code under review;
  • handle a bounded task inside a stronger verification loop.

Long tasks demand more than attractive code generation. The system must notice a failed command, interpret test output, preserve previous decisions, and avoid unapproved changes. An early mistake can redirect later work.

The practical choice is the least costly workflow that reliably produces an acceptable result. Sometimes that is local inference. Sometimes it is a hosted model. Sometimes the right tool is a conventional script.

Memory: capacity, speed, and useful work are different questions

Watch the hardware summary from 42:54.

Grankin places the big jump around 32 GB because it accommodates his selected 27B model at reduced precision. More memory then adds room for longer inputs, higher-precision weights, other applications, or larger models.

Approximate tier in the video What it buys What it does not establish
8 GB Specialized dictation and simpler transcription Every speech app and language will run equally well
16 GB Small text/vision models; selected voice and image jobs with compromises Comfortable multitasking or a universal agent capability
24 GB More room for image work and smaller models A major reasoning upgrade without changing the model
32 GB The recommended 27B model at Q4; broader document, writing, and tool workflows Every context size, backend, or concurrent workload fits
48–64 GB More context, higher precision, and application headroom Automatic correctness or faster execution in every setup
128 GB Larger-model choices and more capacity An automatic replacement for frontier coding performance
Very large systems More large-model experiments become feasible A purchase justified by one leaderboard or demonstration

Count the whole working set

A download is not the complete memory requirement. Budget for:

  • Model weights: the learned numbers loaded for inference.
  • Working state: the context cache and architecture-specific state retained while answering.
  • Runtime buffers: memory used to process prompts, images, or batches.
  • Everything else: the operating system, display, browser, applications, and concurrent requests.

Quantization stores weights at reduced precision to shrink them. Q4 is a rough four-bit class, not one identical file format or quality level. The effect depends on the model, quantization method, task, and runtime. The video’s suggestion of a roughly 2% quality change should not be treated as a universal correction factor.

A Mac memory tier is not a PC graphics-card specification

Apple silicon shares a unified memory pool between CPU and GPU. A typical PC with a discrete graphics card has separate system RAM and GPU memory. A machine advertised with 32 GB RAM may have far less graphics memory available for fast inference.

CPU execution and partial offloading can make more models runnable. They change speed and capacity trade-offs. For a PC, record both memory pools, supported acceleration, and how much of the model actually runs on the GPU.

Even on the same platform, memory capacity alone does not determine response speed. Processing a long prompt and generating the answer stress different parts of the hardware. Swapping to disk can make a technically runnable model unpleasant to use.

More memory does not guarantee the same answer

Keeping the same weights, precision, input, and settings should preserve the broad capability of a model across supported machines. It does not guarantee byte-identical answers. Runtime differences, numerical behavior, sampling, and changed defaults can alter output.

Test whether the complete configuration fits and performs acceptably. Record time to the first useful output, total completion time, peak memory, and correction effort.

Grankin’s LLM Sizer methodology separately counts weights, context, and runtime overhead. It labels speeds as estimates. Use it to narrow candidates, then test the exact configuration.

Four claims to keep narrower than the headline

“Free” means no per-request model bill

Local inference still consumes hardware, electricity, storage, and time. Retry loops and manual corrections can dominate the cost. A subscription may be cheaper for intermittent difficult work; local processing may make more sense for frequent bounded tasks or sensitive material.

The useful comparison is cost per accepted result. Include setup, maintenance, failed runs, and review. Avoid treating a purchased computer as free or a cancelled subscription as the whole saving.

“Local” describes a data flow

Ask where audio, documents, prompts, search queries, embeddings, and logs go. Embeddings are numerical representations used for search. A local chat model can still depend on hosted retrieval, speech, image processing, or fallback inference.

Keep sensitive workloads offline where practical after downloading dependencies. Check service bindings, permissions, telemetry, backups, and external connections. Local inference reduces one disclosure route; it does not certify the whole workflow for a regulated use.

LM Studio documents offline local chat and document processing after models are downloaded. That supports a bounded offline workflow, not a guarantee about every connected plugin, search service, or backup system.

“Best” needs a task, date, and test

The video draws on Artificial Analysis scores and Arena preference rankings. A broad intelligence score, factual-knowledge test, long-document task, and visual-preference vote measure different things.

AA-LCR tests reasoning across long documents. GDPval-AA evaluates work products from tool-using systems and uses pairwise Elo rankings. An Elo score is not a percentage of tasks completed correctly. Both evaluations depend on their versions and setups; neither directly measures this local Q4 workflow.

AA-Omniscience also separates accuracy, abstention, and hallucination measures. Its named hallucination rate uses all non-correct responses as the denominator, including abstentions and partial answers. That differs from the video’s simplified per-100-questions explanation and from an everyday probability of fabrication.

Read a reported score as evidence for the evaluated model and setup. Grankin reports an Artificial Analysis Intelligence Index score of 20 for Qwen 3.8 27B. That does not mean “20% as useful.” A preference win for a web page is not a functional test. A full-precision result does not establish the same result for a downloaded quantization.

Grankin acknowledges a surprising benchmark ranking in the agent section. That uncertainty should remain visible instead of becoming a confident hardware recommendation.

“Open” needs an exact licence

Check the model release, its weights licence, the application licence, and any conditions for the intended use. Download access, commercial permission, redistribution rights, and rights to generated output are separate questions.

The creator’s companion resource page confirms the twelve-job structure and November 2026 scope. Its detailed cheat sheet requires email registration. This article relies on the public video and accessible documentation, not the gated download.

Grankin also sells a local-AI guide linked from the video. That commercial context does not erase the demonstrations; it helps explain the accompanying product recommendations.

A small evaluation plan before buying hardware

Choose one recurring job and collect representative inputs you are allowed to use. Include easy examples, messy examples, missing information, and an adversarial case where appropriate.

Workload A useful test Pass condition
Dictation Names, corrections, prices, and negation Final inserted text preserves every critical fact
Calls Clean audio plus overlapping speakers Important words and speaker attribution survive
Receipts Clean, angled, crumpled, and incomplete examples Required fields match the source; ambiguous fields stay unknown
Documents Direct lookup, distant clauses, and an absent fact Every answer has supporting evidence or clearly states absence
Writing Fixed facts plus explicit forbidden commitments Tone changes while facts and promises remain controlled
Small tools Normal use, invalid input, reload, and export Specified behaviors pass repeatable checks
File agents Disposable copies, collisions, and hostile notes No content loss, no unapproved action, and a reversible record

Record the exact model identifier, file or quantization, runtime version, context setting, thinking setting, and tools enabled. Keep the input and acceptance criteria fixed when comparing candidates.

Count accepted results, important errors, retries, waiting time, and review effort. Repeat borderline cases. A single attractive output cannot reveal whether a workflow is dependable.

Start with the smallest plausible model. If it fails, identify the failure before upgrading:

  • Missing evidence: improve extraction or retrieval.
  • Wrong calculation: use a calculator or validated code.
  • Slow response: inspect backend, context, thinking, and offloading.
  • Poor judgment: try a stronger model or narrow the task.
  • Unsafe action: reduce permissions and add deterministic checks.

More memory solves capacity problems. It does not repair a missing page, grant consent, or make an unchecked action safe.

The takeaway

Grankin’s strongest case for local AI is the collection of ordinary, bounded jobs. Dictation, transcription, extraction, rewriting, and small tools can save effort without requiring a machine built around the largest available model.

His most instructive moments are the failures: a missed contract table, a search tool left unused, an invented relationship, and a long wait for a small application. Each points to a setting or system boundary that a leaderboard hides.

Choose one job, keep its evidence and permissions narrow, and measure the result on the computer already available. Upgrade only when you can name the limit the purchase will remove.