Whitepaper · Costa & Associates

Local Intelligence

Why a personal machine now carries a day of serious work, and the privacy, sovereignty, and safety case for running your intelligence on hardware you own.
Lucas Meyer
Costa & Associates · contact@costa-and-associates.com
Published 2026‑10‑17
DOI: 10.5281/zenodo.23495018
Abstract

For most of the history of machine learning, running a useful model at home was not an open question: the answer was no. We report from a live deployment that the answer has changed for a large class of work. A single desktop machine with 128 GB of unified memory, purchased for about 3,200 dollars, now runs sustained agentic work on a complex codebase using open-weight models. In one representative window it processed roughly 50 million tokens, mostly cached context, and produced about 3,000 changed lines of code in five hours, while its owner worked on other things. It is slower than cloud inference, and for this class of work that proved acceptable. We make three claims. First, owned compute and metered inference scale differently, so a break-even point always exists; where it falls depends on prices that move, and we show the arithmetic instead of asserting a verdict. Second, the privacy, sovereignty, and safety case for owning the substrate is structural, holds for the work that stays local, and no longer requires a large concession in capability. Third, once the substrate is owned, a question that was previously ill-posed becomes well-posed: could a local model improve a model of its own class? We close with that question as a thought experiment, deliberately without a method.

1.The question that belonged to datacenters

For most of the history of machine learning, whether a person could run a useful model at home was not an open question. The answer was no, and the question belonged to datacenters; the alternative for nearly everyone was a widget in a browser that telephoned somebody else's machine. That answer has changed. This paper is about what the change is, why it arrived when it did, and what it means for anyone who intends to own the intelligence they work with. In 2026 the author of this paper no longer relies on a frontier API for working inference, and pays an electricity bill instead.

The evidence is a live deployment: a machine on a desk, open-weight models on the machine, and a body of real work run through them. The figures that follow come from that deployment and not from a benchmark. Their value is that they are real work on hardware anyone could have bought; their limit is that they describe one setup, and we say where that limit matters.

We have written previously on agents with innate stakes that keep learning after deployment [1], on the architecture of an owned, self-hosted personal agent [2], and on admitting agents into the work an organization already runs [3]. Those papers left one question mostly implicit, namely where a personal agent can physically live. The architecture of [2] describes remote inference as "an option the owner may exercise, not a dependency they cannot escape," and takes a private, offline-capable posture as the default, but it does not ask what that default costs in capability. When the deployment described here began, the cost was visible: a smaller and slower model than the API one could have called. This paper asks how much of that cost remains, and finds that for a large class of work it has largely gone. The personal tier of [3] is described there as running on hardware its owner controls; it now runs on an appliance that a person can buy for a few thousand dollars.

Contributions

The paper makes five contributions, and states them here so that they can be taken up, criticized, and reused.

  1. Deployment evidence that a desktop machine running open-weight models now carries sustained agentic work: a representative workload, and the pattern of work that results (§3).
  2. A cost framework for metered versus owned inference, with the break-even arithmetic written out and its limits stated (§4).
  3. An argument that the privacy, sovereignty, and safety case for owning the substrate is structural, grounded in the sovereignty principle of [2], together with an account of what the local machine gives up (§6, §7).
  4. A statement of the conditions under which owning such a machine is justified, for readers asking whether to build their own (§8).
  5. A statement, without method, of the recursive-self-improvement question: can a local model improve a model of its own class? (§10).

What we do not claim is that local compute wins on every task, or that this is a hardware review or a model benchmark. The frontier is faster and larger, and §7 says so where it matters. The claim is narrower: a large and growing class of real work has crossed the line of local viability, and for that class the case for owning the substrate is strong.

2.The machine

The machine is an ASUS GX10, the desktop form of the NVIDIA DGX Spark [5], built around the GB10 superchip: a Blackwell-generation GPU and an Arm CPU in a box that sits on a desk. The unit was purchased in March 2026 for approximately 3,200 dollars. Three of its properties matter to the argument, and the rest of the specification sheet does not.

First, 128 GB of unified memory, shared between the CPU and the GPU [5]. Model capacity has always been bound by memory; the question for any model is whether its weights, plus the context a real workload needs, fit. A single pool of this size holds a quantized model in the tens-of-billions-of-parameters class with room for a long context, on one desktop. Until unified memory of this size reached desktop prices, that configuration meant server hardware.

Second, the compute, read correctly. The vendor's headline figure is up to one petaflop at 4-bit precision [5]. That is a peak figure at low precision, and it governs less of what a person experiences than it suggests. Single-stream generation is limited chiefly by memory bandwidth, which the vendor lists at 273 GB/s [5], and not by peak arithmetic. The compute matters most when long contexts are read in, which is where an agentic loop spends a large share of its time. It is why the cached-context volume of §3 is feasible at all, and why the machine feels slower than a cloud service when one watches it generate.

Third, the form factor. It is a desktop appliance: wall power, no rack, no cooling project. The history of "I will run it myself" is a history of the machine not fitting where the work happens, and a machine that fits on a desk is there when the thought occurs.

It follows that the class of machine that used to define what a person could not do at home has moved to the price, power, and footprint of an ordinary desktop. It does not match datacenter clusters on throughput, and we do not suggest that it does; the relevant comparison is with the machine that used to make "you cannot do that at home" true. There is a familiar precedent. Computing began as a shared resource in rooms that few people could enter, and it moved to the desk when the machine that fit on one became sufficient for the work that mattered to its owner. The personal computer did not beat the mainframe on throughput either. We offer the analogy as a precedent and not as a proof.

3.The work: evidence from a live deployment

The deployment is deliberately ordinary. It runs open-weight models, mostly from the Qwen [6] and Gemma [7] families, on the machine of §2, behind an open-source serving stack of the kind that uses paged memory management for long-context serving [4]; the families were tested against one another. For the work routed locally, the model, the harness, the code, the context, and the work products remain on the machine.

The workload is real work, not a benchmark. Agents run in the background on a fairly complex codebase, of the kind in which a change in one place has consequences in others. In one representative window, taken from the author's own logs and public account of the same period, the machine processed roughly 50 million tokens in five hours, the large majority of them cached context reads, since an agentic loop re-reads much of the same context on every turn. It produced approximately 3,000 lines of changed code, each a candidate for review in the ordinary way.

Two caveats belong beside those figures. Lines changed measure volume and not quality. And the figure describes one window, not an average.

The deployment is also slower than cloud usage, and its owner says so plainly.

The pattern of work that results is the part the figures do not show. Relatively complex research-and-development tasks are started; the person turns to other things for hours, and returns to review. The human role is initiation and judgment: what to start, and what is good enough when it comes back. The machine's role is execution in between. For this class of work slower proved acceptable, because the work was running while its owner was elsewhere. We return to what this changes in §9.

What this section establishes is not a speed claim. Sustained agentic work on a personal machine, on a codebase too complicated to treat as a toy, is a daily pattern and not a demonstration.

4.Metered versus owned

There are two cost structures for the same work, and they grow differently.

Metered inference is priced per token: a variable cost, roughly linear in the work done, on a price list set far from the person using it. The list has changed before and can change again. Inside the token price the buyer also pays for the vendor's infrastructure, margin, and access, and the data that constitutes the work transits the vendor's systems under the vendor's terms.

Owned compute is a capital cost, here about 3,200 dollars depreciating over years, plus a marginal cost that is mostly electricity. The vendor lists a thermal design power of 140 W for the chip and a 240 W power supply [5], so a ten-hour day of agent work consumes at most a few kilowatt-hours at those ratings; this is an estimate from vendor figures and not a measurement at the wall. At typical residential rates that is a small line item. It is not the whole cost: spread the hardware over three years and it comes to about three dollars a day before electricity. The honest owned figure is amortization plus power.

Metered (cloud API) Owned (desktop rig)
What you pay a price per token, set by the vendor capital, amortized; plus electricity per hour of use
Growth with volume linear flat until the machine saturates, then another machine
Price control the vendor's; has changed; can change your power rate; the hardware price is already paid
Your data in the loop transits third-party systems under their terms stays local for work routed locally (§6)
Availability the vendor's schedule, outages, rate limits your machine; failures are local and visible
Maintenance the vendor's yours: stack, drivers, model updates
Ceiling the frontier class the class that fits on the machine, and rising

The break-even arithmetic

Let C be the hardware cost, m what a day of the same work costs metered, and e the daily electricity. The break-even point is C / (m − e) days of that workload. Ignoring electricity, a 3,200-dollar machine breaks even in 160 days if the same day of work would cost 20 dollars metered, and in 640 days if it would cost 5. Those inputs illustrate the arithmetic and are not the author's prices. The structure is what matters. A break-even point always exists for steady work, because one line is linear in volume and the other is flat, but where it falls depends on a price that moves: when prices rise it comes sooner, and when they fall it comes later.

When the machine was purchased in March, this comparison was run against higher-tier cloud APIs. The answer has since moved, because market prices have moved. We think that is the more useful finding: the ownership case does not depend on today's price list, although the payback date does.

Three qualifications follow.

There is a second-order effect that is not a cost. The machine has no meter: no rate limit that thins the work at the moment one wants to do the most of it, no per-seat price, no key a vendor can revoke. A machine that costs nothing per token will run as many agents as it can serve, overnight, and no bill arrives.

5.Why now: three thresholds

The shift is the product of three curves, each of which crossed its own threshold over roughly two years. None is sufficient alone.

Model quality. Open-weight models of the families tested, Qwen [6] and Gemma [7], that fit on a machine of this size now carry multi-hour agentic sessions with review costs inside the ordinary range. Not long ago the same task on the same kind of model was unreliable. They have not reached the frontier, and §7 is about that gap.

Hardware economics. A unified-memory desktop reached a price, roughly 3,000 to 4,000 dollars, at which a person and not only a laboratory can buy it. The 128 GB pool is the specific unlock: it puts a quantized model of this class and a large context on one machine.

The harness. The software that turns a model into a worker, meaning the agentic loop, the tools, the permissions, and the memory, matured into something a person can run without being a platform team. One practical point from testing is not obvious: pair the open model with the harness its maker provides. A harness is tuned to a model's tool conventions and failure modes, and a mismatch discards capability that the matched pair gives for free. This is an observation from use and not a benchmark result. It does not conflict with [2]: the loop described there is provider-agnostic by design, which is what allows the matched harness to be chosen per model.

flowchart LR A["Model quality
open models that sustain multi-hour work"] --> D B["Hardware economics
128 GB unified memory at desktop price"] --> D C["Harness maturity
loop, tools, permissions — maker-matched"] --> D D["A day of real work, on a desk"]
The three thresholds are conjunctive. Quality without hardware is a model that cannot be run at home; hardware without quality is an expensive paperweight; both without a harness is a chatbot. All three together give a day of work (§3).

6.Privacy, sovereignty, and safety

The economics of §4 are the weakest of the three reasons to run local. They make the decision defensible; the reasons that follow make it sound. Each is structural, in that it follows from where the computation happens and not from the character of any vendor.

Privacy. The local contract is that data does not leave. The cloud contract is that the vendor does not misuse it. The first is the absence of a path; the second is a promise about a path. A personal agent knows the work in progress, the correspondence, the unannounced projects, and the family, and running it locally removes the question of what may be sent. One condition applies: the guarantee holds for the work that is actually routed locally. If hard tasks go to a hosted API (§7), privacy depends on the routing rule set for them, and that rule should be decided deliberately and written down.

Sovereignty. Sovereign Intelligence Systems [2] stated the principle that personal AI should be owned and not rented. Until recently the principle carried a visible capability price, and for a large class of work that price has shrunk a great deal. Concretely, owning the stack means no deprecation schedule set by someone else, no terms that change underneath, no revocation of access, no model withdrawn from the menu mid-project, and no vendor outage as an existential event. The model is a version chosen, kept as long as one likes, in a state that can be inspected.

Safety. In two directions. For the operator, there is no network hop in the hot path, and so no route by which code and context reach a vendor. The stack is fixed and updates when its owner decides, and failures happen in front of the operator on hardware that can be opened. Local operation does not remove the other risks. An agent with a shell and network access can still be misled by content it reads, or make a destructive mistake. The control is the one described in [3]: credential the agent to its role, give it only the permissions the work needs, and keep a human on the transitions that matter. For the larger system, if everyone's personal agents run on a handful of frontier APIs, then everyone's private work runs through a handful of datacenters and threat models. Owning the substrate distributes that concentration, which is why sovereignty is a systemic property as well as a personal preference.

7.What the local machine gives up

A paper that omitted this section would be an advertisement. The trade is real, and it has five terms.

It is slower. Frontier clusters are faster, and for interactive use the difference is felt. The claim is not that local is faster. For background work that runs while the owner does something else, the speed is enough, which is why the pattern of §3 is possible.

It is smaller. These models are not the frontier. For the hardest fraction of problems, the ones that want the largest model available, the quality gap is real. The local machine carries the large majority of the work and cedes the demanding minority, which can still be sent to an API when a task requires it. A sovereign system is a default one, not a closed one.

Long runs are bounded. Every model has a finite context window. Multi-hour sessions depend on the harness managing context well, and there is a limit to how far any run can go before it must be summarized, restarted, or divided into smaller tasks. Dividing work into reviewable pieces is part of the skill.

The owner is the platform team. The serving stack, the drivers, the model updates, and the occasional failure are the owner's. They are small, local, visible, and recoverable, but they are not zero, and the cost is paid to no one else.

The hardware depreciates. The 3,200 dollars of March 2026 is partly spent already, and the frontier does not stand still while the machine ages. In the metered arrangement the vendor carries this cost; in the owned arrangement the owner does.

Read together, the five terms are bounded and legible. We do not claim that local wins everywhere. We claim that for the work a person actually does, local is now sufficient more often than is commonly assumed, and that for that class of work the ownership case is strong.

8.Conditions of fit

A colleague asked, after the first public note on this setup, which hardware to buy and which models to run. Our answer is not a recommendation. It is a statement of the conditions under which owning a machine of this kind is justified, in the manner of the worker contract of [3]: each condition can be checked before money is spent, and a reader who fails one should know it.

The case holds when

The case does not hold when

Checks before purchase

  1. Measure the volume. Log a week of real token use on whatever is used today, including cached reads, and run the arithmetic of §4 with those numbers.
  2. Test the model class first. Run the open models that would be hosted locally on a hosted endpoint, using a non-sensitive project, and check whether the quality suffices. This costs little and says more than a benchmark.
  3. Size the memory for weights plus context, not weights alone. Long agentic sessions need a large context, and that is where memory goes.
  4. Begin with the model maker's own harness. It was the cheapest capability gain found in testing.
  5. Decide the routing rule. What stays local, what may go to an API, and who decides.

A single purchase, made in March, met the need that prompted it. That is one data point and not a recommendation for every reader; the checks above are how a reader produces their own.

9.The changed pattern of work

The most visible effect of the shift is in the day and not in the machine. §3 described the pattern; what it changes is the division of labor. The person holds intent and review, and the machine holds execution in between. The skill at the human end moves from doing to choosing and judging, which is not a smaller skill: the review is only as good as the judgment in it, and the judgment remains entirely the person's.

There is also a behavioral effect that the economics only implied. Metered resources change how they are used, and an invoice is a meter on ambition. Work that would be hesitated over when each run has a visible price becomes easy to start when the marginal cost is small: the batch is batched, agents run in parallel, and the long job runs overnight. This is experience and not a controlled finding, but we think it generalizes.

The pattern is not specific to code. Any token-intensive personal work fits the shape of start, step away, and return to review. It also connects the series. The personal tier of [3] is the agent that runs on this machine, and the continuous agent of [1], the one that carries its stakes between visits, now has an affordable and sufficient home.

10.A thought experiment: recursive self-improvement

There is a question that the economics of this paper make well-posed and that the earlier state of the world did not. We offer it explicitly as a thought experiment, without a method and without a claim that it is possible.

Self-improvement against a fixed verifier means sampling many attempts, checking them with something objective such as tests, and training on the ones that pass. It is well established and needs no larger teacher, so it works in principle at any model size. Two things limit it for a local model. The first is reach: the loop learns only from tasks the model sometimes solves, so a smaller model has fewer tasks to climb. The second is recursion: improving against a verifier that its owner supplies is ordinary reinforcement learning, and the open question is whether a model could improve the verifier and the tasks themselves. Frontier development shows a partial version of that today, with humans, data, and compute still in the loop.

The question, then. A local model now contributes useful changes to the local systems it works in. What happens when the object of the improvement is the model itself? Not a larger model but one of the same class and size: a successor. Could a model of the class used here become the next version of itself, adapted to its owner's own work?

The economics matter, and they do not cover everything. A loop that improves models is token-hungry far beyond chat: evaluation, data generation, verification, and repetition. At metered prices a single iteration of such a loop has been a laboratory budget. An owned substrate with near-zero marginal cost makes the inference side of the loop conceivable at personal scale. The update step is different. Training has its own memory and compute profile, and nothing in §4 addresses it. We leave that open.

The idea is not new in outline. Work such as STaR [8] and self-rewarding language models [9] has explored models generating training signal for themselves. What changes here is the owner and the scale: one person, one machine, no meter.

The thought experiment is worth having even if the answer is no. If it works, sovereignty extends from the use of the model to the model itself, and a model could adapt to its owner's work in a way no vendor's release cycle is organized to do. A loop that runs locally also fails locally: if the successor is worse, the owner keeps the old model, and the failure does not propagate to people who were never asked. Two cautions apply. A degraded model can degrade quietly, especially in judgment, and a model's own judgment is a weak instrument for evaluating its successor. And the infrastructure for monitoring, bounding, and reverting weight changes is not yet mature [1]. Distribution of capability also cuts both ways: the property that spreads concentration risk also spreads the ability to run such loops without oversight.

We do not say how, whether, or when. We say only that the question has changed shape, from "is this possible?" to "what would it mean if it were?", and that the change came from the economics of §4 and not from any advance in the art.

11.Closing thoughts

The second paper in this series argued that personal intelligence should be owned and not rented [2]. When the work described here began, that position carried a visible price: a smaller model and a slower answer. The claim of this paper is that for a large class of work the market has shrunk that price. The models crossed a threshold, the hardware crossed a threshold, and the harness crossed a threshold, and together they give a day of serious work on a desk, at the marginal cost of a wall socket plus the amortized machine.

Owned intelligence is not free and is not best at everything. For a growing share of what a person does, it is now a reasonable default. And the horizon is the question of §10: if the substrate is yours, the model may be the next thing you own.


References

  1. L. Meyer, Costa & Associates. Learning Systems and Innate Behavior. 2026. DOI: 10.5281/zenodo.20301638.
  2. L. Meyer, Costa & Associates. Sovereign Intelligence Systems. 2026. DOI: 10.5281/zenodo.20790563.
  3. L. Meyer, Costa & Associates. Agentic Work Systems. 2026. DOI: 10.5281/zenodo.21852850.
  4. W. Kwon et al. "Efficient Memory Management for Large Language Model Serving with PagedAttention." Proc. ACM SIGOPS Symposium on Operating Systems Principles (SOSP). 2023. arXiv: 2309.06180.
  5. NVIDIA. DGX Spark product specifications. 2026. nvidia.com/en-us/products/workstations/dgx-spark, accessed 2026‑10‑17.
  6. Qwen Team, Alibaba. Qwen3 Technical Report. 2025. arXiv: 2505.09388. See also the family announcement, "Qwen3: Think Deeper, Act Faster," qwenlm.github.io/blog/qwen3, April 29, 2025, accessed 2026‑10‑17.
  7. Gemma Team, Google. Gemma 3 Technical Report. 2025. arXiv: 2503.19786. Model card: Gemma 3 model card, Google AI for Developers, ai.google.dev/gemma/docs/core/model_card_3, accessed 2026‑10‑17.
  8. E. Zelikman, Y. Wu, J. Mu, N. D. Goodman. "STaR: Bootstrapping Reasoning With Reasoning." NeurIPS. 2022. arXiv: 2203.14465.
  9. W. Yuan et al. "Self-Rewarding Language Models." 2024. arXiv: 2401.10020.