<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Salaheldinaz</title><link>https://salaheldinaz.com/</link><description>OSINT · Intelligence · Cyber Security · Automation · Technologist · Investigator</description><language>en-US</language><lastBuildDate>Sun, 15 Nov 2026 10:46:05 +0000</lastBuildDate><atom:link href="https://salaheldinaz.com/tags/privacy/" rel="self" type="application/rss+xml"/><item><title>Running AI locally</title><link>https://salaheldinaz.com/blog/running-ai-locally/</link><guid isPermaLink="true">https://salaheldinaz.com/blog/running-ai-locally/</guid><pubDate>Sun, 15 Nov 2026 00:00:00 +0000</pubDate><description>Source material you did not publish should not go into somebody else's API. What a model on your own machine is genuinely good enough for, measured across 5 models and 5 task shapes — including the 3 failures that explain why its output is a draft.</description><category>osint</category><category>ai</category><category>automation</category><category>privacy</category><category>methodology</category><content:encoded><![CDATA[<span class="hero-label not-prose">The Analyst&#39;s Stack · Methods</span>

<p>Sooner or later someone who has read <a href="https://salaheldinaz.com/blog/ai-dos-and-donts-for-investigators/">the do&rsquo;s and
don&rsquo;ts</a> asks the question that follows from
them:</p>
<p><em>The material on my desk is not mine to publish. Can I use a model on it at all?</em></p>
<p>You can, if the model runs on your machine. This post is what that costs, what you get, and
— with real measurements — where it stops being good enough.</p>
<h2 id="the-reason-and-it-is-not-the-money">The reason, and it is not the money</h2>
<p>Local models get sold on price. That is the weakest argument for them.</p>
<p>The real one is that <strong>source material you did not publish should not go into somebody
else&rsquo;s API.</strong> The do&rsquo;s and don&rsquo;ts treated that as a disclosure decision, and that is
exactly what it is. A
leaked document, a source&rsquo;s messages, an unpublished draft, a dataset about identifiable
people: send any of those to a hosted model and they have left your control. They sit on
hardware you do not own, under a retention policy you probably have not read, reachable by
anyone who can compel the company holding them.</p>
<p>For a public web page, fine. For material somebody trusted you with, this is not a
preference about tooling. It decides whether you get to use a model on that material at
all.</p>
<p>The other reasons are smaller and still real. No per-token bill, so the backfill nobody
budgets for — the 18 months of archive you want to process the week after the
pipeline finally works — costs electricity instead of an invoice. No rate limit. It works
on a train with no signal.</p>
<p>And one that sounds administrative and is not. <strong>The model version stays where you put
it.</strong> <em>Same input, same answer, or you cannot defend it later</em> is hard to honour against
a hosted endpoint that gets updated underneath a stable name. A local model is a file on
a disk. Keep the file and you can re-run March&rsquo;s classification in September and get
March&rsquo;s answer back — the difference between a method and an anecdote.</p>
<figure class="diagram not-prose">
  <img class="diagram-light" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-route_light.svg" width="968" height="312" alt="A routing decision. The material reaches one question: can it leave this machine? If it is already public it goes to a hosted model; if it is not yours to publish it goes to a local model, which is highlighted. Both paths then pass through the same human verification step, where a person opens the source, and only then become a finding." loading="lazy" decoding="async">
  <img class="diagram-dark" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-route_dark.svg" width="968" height="312" alt="A routing decision. The material reaches one question: can it leave this machine? If it is already public it goes to a hosted model; if it is not yours to publish it goes to a local model, which is highlighted. Both paths then pass through the same human verification step, where a person opens the source, and only then become a finding." loading="lazy" decoding="async">
  <figcaption class="post-caption"><strong>One question, asked once for the whole pipeline, not item by item at two in the morning.</strong> Note what is identical on both paths.</figcaption>
</figure>

<p>The gate is on both branches on purpose. Running a model on your own hardware changes who
can read your material. It changes nothing about whether the output is true.</p>
<h2 id="the-setup-in-about-ten-minutes">The setup, in about ten minutes</h2>
<p>You need 3 things: a runner, a model, and one request.</p>
<p>The <strong>runner</strong> is a small program that loads models and answers requests on your own
machine. I use Ollama. Install it from its own download page, and it starts listening on
<code>127.0.0.1:11434</code> — a loopback address, meaning a network address that never leaves the
computer it is on. That single detail is the entire privacy argument, expressed in
configuration.</p>
<p>Then pull a model and talk to it:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">ollama pull &lt;a small instruct model&gt;   <span class="c1"># a few GB, downloaded once</span>
</span></span><span class="line"><span class="cl">ollama list                            <span class="c1"># what you have, and how big each one is</span>
</span></span><span class="line"><span class="cl">ollama run &lt;that model&gt; <span class="s2">&#34;Give me the three dates mentioned in this text: ...&#34;</span>
</span></span></code></pre></div><p>Here is part of what <code>ollama list</code> reports on my machine. This is what happens to be
installed today, not the set the benchmark below was run on; those models stay anonymous in
this post. The full list is longer, so <code>grep</code> trims it to fit here:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ ollama list | grep -E &#39;^(NAME|granite4\.1:3b|qwen3-embedding:|gemma4:|gpt-oss:120b)&#39;
</span></span><span class="line"><span class="cl">NAME                       ID              SIZE      MODIFIED
</span></span><span class="line"><span class="cl">gemma4:latest              c6eb396dbd59    9.6 GB    13 days ago
</span></span><span class="line"><span class="cl">gemma4:26b                 5571076f3d70    17 GB     5 weeks ago
</span></span><span class="line"><span class="cl">granite4.1:3b              6fd349357287    2.1 GB    8 weeks ago
</span></span><span class="line"><span class="cl">gpt-oss:120b               a951a23b46a1    65 GB     8 weeks ago
</span></span><span class="line"><span class="cl">qwen3-embedding:8b         64b933495768    4.7 GB    8 weeks ago
</span></span></code></pre></div><div class="post-caption not-prose"><strong>What you actually own.</strong> Disk size is the floor; memory at your context size is the real bill.</div>

<p>For anything in a pipeline you want the second form — an HTTP request, so the model step
looks like every other step:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="kn">import</span> <span class="nn">requests</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">ask_local</span><span class="p">(</span><span class="n">prompt</span><span class="p">,</span> <span class="n">model</span><span class="o">=</span><span class="s2">&#34;my-small-model&#34;</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="s2">&#34;&#34;&#34;One request to a model on this machine. 127.0.0.1 is the point.&#34;&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="n">r</span> <span class="o">=</span> <span class="n">requests</span><span class="o">.</span><span class="n">post</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">        <span class="s2">&#34;http://127.0.0.1:11434/api/generate&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="n">json</span><span class="o">=</span><span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;model&#34;</span><span class="p">:</span> <span class="n">model</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;prompt&#34;</span><span class="p">:</span> <span class="n">prompt</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;stream&#34;</span><span class="p">:</span> <span class="kc">False</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">            <span class="s2">&#34;options&#34;</span><span class="p">:</span> <span class="p">{</span><span class="s2">&#34;temperature&#34;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="s2">&#34;num_ctx&#34;</span><span class="p">:</span> <span class="mi">8192</span><span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="p">},</span>
</span></span><span class="line"><span class="cl">        <span class="n">timeout</span><span class="o">=</span><span class="mi">300</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">r</span><span class="o">.</span><span class="n">raise_for_status</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="n">r</span><span class="o">.</span><span class="n">json</span><span class="p">()[</span><span class="s2">&#34;response&#34;</span><span class="p">]</span>
</span></span></code></pre></div><p><code>temperature: 0</code> pins the randomness setting the do&rsquo;s and don&rsquo;ts tell you to record.
<code>num_ctx</code> is how much text the model looks at in one go — 8,192 tokens is roughly 6,000
words, and it is what every measurement below was taken at.</p>
<p>The hardware bill is <strong>VRAM</strong> <em>(the memory on your graphics card, separate from your
computer&rsquo;s main memory; a model has to fit inside it to run at full speed)</em>. Measured: a
3-billion-parameter model occupied 7 GB, a 14B about 18 GB, a 26B 21–23.5 GB. A laptop
with 8 GB of VRAM runs the first of those, and the first of those wins one of the 5
tests below outright.</p>
<div class="callout callout-info not-prose"><p class="callout-title">Credit where it is not mine</p><div class="callout-body"><p>Two of the tools in this post are other people&rsquo;s work and I want that stated plainly.
<strong>Ollama</strong> is not my project. Nor is the small desktop tray utility I use to start, stop
and switch between local models — I have contributed 2 commits out of 10 to it, and it
is designed and maintained by somebody else. I use both daily. I did not build either.</p>
<p>This matters beyond politeness: a series about evidence chains cannot be casual about
attribution in its own copy.</p>
</div>
</div>

<h2 id="what-the-measurements-are">What the measurements are</h2>
<p>Everything below comes from one benchmark I ran on my own hardware: 5 local models
across 5 task shapes, graded 1 to 5 by me against written criteria, one sample per
model per task, at a fixed context size, with each model run alone on the card.</p>
<p><strong>One sample per cell.</strong> Read the grades accordingly: a 5 and a 4 in the same column is not
a meaningful gap. A 5 and a 1 is — which is why the failures get more space below than the
wins.</p>
<p>The card is a workstation GPU with roughly 96 GB of VRAM, far more than most people have.
Read the timings as relative, not as what your laptop will do.</p>
<h2 id="what-they-are-genuinely-good-enough-for">What they are genuinely good enough for</h2>
<h3 id="retrieval-from-a-long-document">Retrieval from a long document</h3>
<p>This is the headline and it surprised me.</p>
<p>The test: a 3,006-word document, about 4,600 tokens, with 3 specific facts planted at
15%, 55% and 90% of the way through. Find all 3, exactly, without inventing anything.</p>
<p>Of the 5, 4 returned 3 out of 3, exactly correct, no fabrication. The fifth got all
3 right too and lost a point for a formatting breach. The fastest was the smallest
model in the fleet: <strong>0.5 seconds, on 7 GB of VRAM.</strong></p>
<p>Size buys nothing on this job. That makes &ldquo;pull the relevant paragraph out of this
40-page filing&rdquo; an essentially free local operation, and it is the one on this list
that pays back most, because it is the one you do 50 times a day.</p>
<h3 id="bulk-classification-and-tagging">Bulk classification and tagging</h3>
<p>The same small model ran at 320 to 340 tokens per second, loaded in 8.9 seconds, and left
about 90 GB of the card free. At that throughput a queue of thousands of items is an
afternoon of unattended work with no bill attached.</p>
<p>This is the shape <a href="https://salaheldinaz.com/blog/where-ai-actually-fits-in-osint/">where AI fits</a> called triage: sort the pile
so a person reads the promising end first, never delete, keep the low-scored items on
screen. Local fits it because the failure mode is a shortlist in a slightly wrong order
rather than a false claim.</p>
<h3 id="translation-to-decide-what-to-read">Translation, to decide what to read</h3>
<p>Two of the 5 models produced publishable English from Arabic. One took 11.4 seconds; the
other took <strong>1.3 seconds</strong> and was just as accurate on every figure. A third was accurate
throughout and lost a point only for stiff phrasing.</p>
<p>There is one caveat the benchmark makes unavoidable. The small model that was brilliant at
retrieval scored <strong>2</strong> here. It turned a distance of 2.5 kilometres into &ldquo;one and a half
kilometres&rdquo; and described a double fence as separating service lanes when the source said
the opposite. Size buys you something on translation and nothing on retrieval, and you
cannot reason from one to the other — which is the argument for measuring rather than
guessing.</p>
<p>The same rule still holds: you translate to decide what to hand a person, never to quote.</p>
<h3 id="summarising-text-you-supply">Summarising text you supply</h3>
<p>The most fragile shape in the whole benchmark, so treat it with the least trust.</p>
<p>Only one model of 5 reached a 5 on a 3-bullet summary of a news article: faithful
figures, correct grammar, format obeyed. Three others were graded 3, each with a <em>different</em> factual
drift. One moved a dump site from 12 nautical miles offshore to 11. One asserted
that sediment had been &ldquo;proven to contain heavy metals&rdquo; when the article said the opposite,
that levels were within permitted limits — a fabrication of exactly the kind that gets a
correction published.</p>
<p>Summarise locally to sort your own reading. Not into anything that leaves your desk.</p>
<h2 id="where-they-fall-short-measured">Where they fall short, measured</h2>
<p>Three specific failures from the same benchmark. These are the most useful paragraphs in
this post, because each one is invisible in the output.</p>
<h3 id="it-silently-dropped-3-of-4-required-fields">It silently dropped 3 of 4 required fields</h3>
<p>I asked all 5 models for entity extraction into a strict schema: people, organizations,
locations, dates. Raw JSON only, no commentary.</p>
<p>The 3B model returned a valid JSON object containing <code>dates</code> — and nothing else. <code>people</code>,
<code>organizations</code> and <code>locations</code> were not empty lists. They were <strong>absent</strong>. Grade 1.</p>
<p>Consider what that does downstream. Code reaching for <code>data[&quot;people&quot;]</code> crashes, which is
the good outcome. Code reaching for <code>data.get(&quot;people&quot;, [])</code> — what a careful programmer
writes — gets an empty list, records zero people, and moves on. The pipeline stays green,
every document has no people in it, and nothing anywhere says so.</p>
<p>When I went back to reproduce that failure for this post, it did not happen. The same
model, the same 4-key schema and instruction, an invented news item, 5 fresh runs:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">$ python3 retry.py
</span></span><span class="line"><span class="cl">asking for 4 keys: people, organizations, locations, dates
</span></span><span class="line"><span class="cl">  run 1: 4/4 keys returned  complete
</span></span><span class="line"><span class="cl">  run 2: 4/4 keys returned  complete
</span></span><span class="line"><span class="cl">  run 3: 4/4 keys returned  complete
</span></span><span class="line"><span class="cl">  run 4: 4/4 keys returned  complete
</span></span><span class="line"><span class="cl">  run 5: 4/4 keys returned  complete
</span></span></code></pre></div><div class="post-caption not-prose"><strong>The failure would not come back on demand.</strong> Real output of a 20-line script asking the
model on this machine. An earlier attempt, 10 runs across 2 models and 4 inputs, with and
without the format instruction, did not bring it back either.</div>

<p>That is worse than a reliable fault, not better. A model that fails every time is one you
catch on your first test. A model that fails occasionally passes your spot-check, ships,
and drops fields on the days nobody is looking. So the lesson is not that this model is
unreliable — it is that <strong>a schema check has to run on every response, not on a sample.</strong>
Sampling is what missed it here.</p>
<p>The fix is not a better prompt. It is validating every response against the schema and
treating a missing key as a failed run.</p>
<h3 id="it-dropped-a-leading-digit">It dropped a leading digit</h3>
<p>On the Arabic summarisation task the 14B model produced 3 correctly formatted bullets
in fluent prose, and rendered the article&rsquo;s headline figure of <strong>138 million as 38
million</strong>. Graded 2, and the grade is generous.</p>
<p>There was no hedge, no malformed output, no sign of strain. The sentence reads exactly like
the sentence that would have been there if the number were right. A reviewer skimming for
tone finds nothing wrong with it, because nothing is wrong with it except the fact.</p>
<p>A different model in the same benchmark corrupted a string in a comparable way: it turned a
lowercase <em>l</em> into the digit <em>1</em> inside an organisation name — a one-character change that
would break every downstream join that name participates in, silently, while the extraction
itself reports success.</p>
<p>Numbers and proper nouns are where models fail most and where verification is cheapest.
Check every figure against the source. That is a rule with a measurement behind it now.</p>
<figure class="diagram not-prose">
  <img class="diagram-light" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-dropped-digit_light.svg" width="760" height="306" alt="The same invented source sentence, putting an allocation at 138 million over 4 years, summarised twice. One run returns 138 million and matches the source. The other returns 38 million: the leading digit is gone, and nothing else about the output — format, grammar, confidence — is wrong." loading="lazy" decoding="async">
  <img class="diagram-dark" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-dropped-digit_dark.svg" width="760" height="306" alt="The same invented source sentence, putting an allocation at 138 million over 4 years, summarised twice. One run returns 138 million and matches the source. The other returns 38 million: the leading digit is gone, and nothing else about the output — format, grammar, confidence — is wrong." loading="lazy" decoding="async">
  <figcaption class="post-caption"><strong>One model, one sentence, two runs, and a digit gone from one of them.</strong> Nothing else in the failing output — format, grammar, confidence — tells you which run to trust. The sentence is invented for the illustration; the failure is the one the benchmark measured.</figcaption>
</figure>

<h3 id="the-code-compiled-cleanly-and-rejected-every-valid-input">The code compiled cleanly and rejected every valid input</h3>
<p>I gave all 5 models a written spec for a small parser: read a fixed-format message line,
check its checksum, split its fields. Then I ran the results through a strict compiler and
11 functional test cases.</p>
<p>Of the 5, 4 compiled clean. <strong>One passed the tests.</strong></p>
<p>The coder-branded model compiled, passed 8 of 11, and had invented a validation rule the
spec never mentioned: it required the payload to be hexadecimal, when the format&rsquo;s payload
is a different encoding entirely. Every real message failed it. The largest model made the
same class of mistake with a different invented rule — a field required to be non-empty
when empty is the normal case. Also 8 of 11, also rejects genuine traffic. The 14B managed
7 of 11 and was broken in a way that meant no valid input parsed at all.</p>
<p>Four models produced code a compiler pronounced correct, and 3 of those 4 silently
refuse real data. <strong>Compilation is not correctness.</strong> Locally generated code needs a
functional test against real input before you trust one row of its output.</p>
<p>A fourth failure is blunter. The largest model leaked its own visible reasoning into the
output on 3 of 5 tasks — paragraphs of &ldquo;let me go through each sentence again&rdquo;
wrapped around the answer. Largely right, entirely unusable, because every format contract
downstream broke on them. It scored 3.2 out of 5, tied with a model a seventh of its size.</p>
<div class="callout callout-warning not-prose"><p class="callout-title">The one-line version</p><div class="callout-body">Across 5 models and 5 task shapes, every failure above was <strong>silent</strong>: valid output,
correct shape, wrong content. Local output is a draft. The verification gate from those 2
earlier posts is not optional here — it is the only thing standing between these failures and your
reporting.</div>
</div>

<h2 id="the-operational-facts-that-actually-decide-it">The operational facts that actually decide it</h2>
<p>Capability is not what makes or breaks a local setup day to day. Two numbers and one consequence do.</p>
<figure class="diagram not-prose">
  <img class="diagram-light" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-first-call_light.svg" width="776" height="200" alt="What one local request costs, in 4 steps: the request arrives, the model is read off disk into the graphics card in 9 to 86 seconds, which is the highlighted step and happens only on the first call, then generation, which was often under 2 seconds, then the answer comes back." loading="lazy" decoding="async">
  <img class="diagram-dark" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-first-call_dark.svg" width="776" height="200" alt="What one local request costs, in 4 steps: the request arrives, the model is read off disk into the graphics card in 9 to 86 seconds, which is the highlighted step and happens only on the first call, then generation, which was often under 2 seconds, then the answer comes back." loading="lazy" decoding="async">
  <figcaption class="post-caption"><strong>The cost nobody budgets for is the blue box.</strong> It is paid once per keep-alive window and it dwarfs generation on the larger models.</figcaption>
</figure>

<p><strong>Cold load.</strong> The first request after a pause pays to read the model off disk into the
card. Measured: 8.9 s for the 3B, 14.1 s for the 14B, 19.5 s for the 26B, 51.3 s for a
50 GB model and <strong>85.7 s</strong> for the largest. Generation itself was often under 2
seconds. That ratio is the whole scheduling argument: a big model is worth loading for a
batch of 500 documents and absurd for one short question.</p>
<p><strong>VRAM footprint.</strong> Measured on the card: 7 GB, 18 GB, 21–23.5 GB, 50 GB and about 94 GB for the
5 models. The practical reading is that the small one leaves roughly 90 GB free and the
large one leaves nothing.</p>
<figure class="diagram not-prose">
  <img class="diagram-light" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-vram_light.svg" width="776" height="300" alt="A bar chart of graphics-card memory used by each of 5 local models, loaded one at a time, against a card of roughly 96 GB. The 3B model uses 7 GB and leaves about 90 GB free. The 14B uses 18 GB, the 26B 21 to 23.5 GB, and the fourth model 50 GB. The largest uses about 94 GB, 95,875 MiB of 97,887, leaving 2 per cent of the card." loading="lazy" decoding="async">
  <img class="diagram-dark" src="https://salaheldinaz.com/blog/running-ai-locally/images/m2-vram_dark.svg" width="776" height="300" alt="A bar chart of graphics-card memory used by each of 5 local models, loaded one at a time, against a card of roughly 96 GB. The 3B model uses 7 GB and leaves about 90 GB free. The 14B uses 18 GB, the 26B 21 to 23.5 GB, and the fourth model 50 GB. The largest uses about 94 GB, 95,875 MiB of 97,887, leaving 2 per cent of the card." loading="lazy" decoding="async">
  <figcaption class="post-caption"><strong>The gap is the budget.</strong> Whatever a model leaves free is all you have for a second model, another job or a longer document.</figcaption>
</figure>

<p><strong>A large model can leave room for nothing else.</strong> This is the finding I did not expect to
matter and now plan around. The largest model occupied 95,875 MiB of 97,887 available — 2,012
MiB of headroom, 2 per cent. It ran entirely on the GPU with no slowdown, and while it
was loaded the card was full. No second model, no other job, and no larger context window:
8,192 tokens was near its ceiling, so a longer document would spill onto the CPU and
collapse its speed.</p>
<p>That reshapes how you build. If the pipeline wants a translation model and a classification
model resident at once, 2 small models that fit together beat one large one that does
not — and the small one wins the retrieval task anyway.</p>
<div class="limitation not-prose"><p class="limitation-title">What local does not buy you</p><div class="limitation-body"><p><strong>It does not hand you a frontier model.</strong> The best local result here was one model with a
mean of 4.8 across 5 tasks, and that average sits on single samples. On long, messy
reasoning — the shape where hosted models are still clearly ahead — local is the weaker
instrument and pretending otherwise helps nobody.</p>
<p><strong>You become the operator.</strong> Nobody patches the model for you, nobody notices when a
driver update breaks the runner, and nobody is on call when the card is full. The bill
moved from a card statement to your afternoons.</p>
<p><strong>It protects the material from a vendor, not from everything.</strong> A model on your machine
removes one disclosure path. It does nothing about a compromised laptop, a synced folder, a
backup, or the most common leak of all — pasting the local model&rsquo;s <em>output</em> into a hosted
tool to tidy it up. The boundary only holds if the whole pipeline respects it.</p>
<p><strong>The measurements are mine, not yours.</strong> One sample per cell, one card, one set of
fixtures, one date. Model releases move faster than this post will age. Use the method —
5 task shapes, written grading criteria, your own material — and get your own numbers.</p>
</div>
</div>

<h2 id="where-i-would-start">Where I would start</h2>
<p>Pick the retrieval job. Take the longest document you read this week, run the smallest
model that fits on your card, and ask it for 3 specific facts you already know are in
there. A minute later you will know whether this is useful to you — and you will have found
out on material you were never going to send anywhere.</p>
<p>Then do what <a href="https://salaheldinaz.com/blog/what-automation-means-for-an-osint-analyst/">the first post</a> asked and
write the step down, one line per stage. A local model is stage 4 and nothing else: a
private first pass whose failures are silent. Treat its output as a draft.</p>
]]></content:encoded></item></channel></rss>